From ecfed1132de691df3a87b922722d40adc6fda9df Mon Sep 17 00:00:00 2001
From: Vera Clemens <clemens@zbmed.de>
Date: Thu, 3 Sep 2026 17:48:59 +0200
Subject: [PATCH 1/3] feat: add dataset relations support

---
 conf/solr/schema.xml                          |    1 +
 doc/sphinx-guides/source/api/native-api.rst   |  269 +++-
 .../relationTypes/relationTypeAllFields.json  |   10 +
 scripts/api/data/role-curator.json            |    1 +
 scripts/api/data/role-editor.json             |    1 +
 scripts/api/data/role-manager.json            |    1 +
 .../edu/harvard/iq/dataverse/Dataset.java     |   11 +-
 .../harvard/iq/dataverse/DatasetVersion.java  |   25 +-
 .../dataverse/DatasetVersionDifference.java   |   38 +
 .../iq/dataverse/EjbDataverseEngine.java      |   18 +
 .../iq/dataverse/api/AbstractApiBean.java     |   87 +-
 .../iq/dataverse/api/DatasetRelations.java    |  321 ++++
 .../harvard/iq/dataverse/api/Datasets.java    |   47 +-
 .../dataverse/api/dto/DatasetRelationDTO.java |   59 +
 .../api/imports/ImportGenericServiceBean.java |   13 +-
 .../api/imports/ImportServiceBean.java        |   16 +-
 .../dataverse/authorization/Permission.java   |    3 +-
 .../datasetrelation/DatasetRelation.java      |  144 ++
 .../DatasetRelationAlgorithm.java             |   51 +
 .../DatasetRelationIndexing.java              |   71 +
 .../DatasetRelationServiceBean.java           |  227 +++
 .../datasetrelation/DatasetRelationType.java  |  147 ++
 .../DatasetRelationTypeException.java         |   16 +
 .../DatasetRelationTypeServiceBean.java       |  155 ++
 .../ExternalDatasetRelation.java              |   77 +
 .../InternalDatasetRelation.java              |   67 +
 .../SqlDirectDatasetRelationAlgorithm.java    |  380 +++++
 .../engine/command/CommandContext.java        |    7 +-
 .../impl/CreateDatasetRelationCommand.java    |   53 +
 .../CreateDatasetRelationTypeCommand.java     |   47 +
 .../impl/DeleteDatasetRelationCommand.java    |   40 +
 .../DeleteDatasetRelationTypeCommand.java     |   50 +
 .../command/impl/DestroyDatasetCommand.java   |    4 +
 .../FinalizeDatasetPublicationCommand.java    |   10 +-
 .../impl/ReplaceDatasetRelationsCommand.java  |   77 +
 .../impl/UpdateDatasetVersionCommand.java     |    2 +-
 ...ateDatasetVersionWithRelationsCommand.java |   70 +
 ...dateDefaultDatasetRelationTypeCommand.java |   32 +
 .../pidproviders/doi/XmlMetadataTemplate.java |   64 +-
 .../iq/dataverse/search/IndexServiceBean.java |    6 +-
 .../iq/dataverse/search/SearchFields.java     |    2 +
 .../iq/dataverse/search/SolrSearchResult.java |   14 +-
 .../search/SolrSearchServiceBean.java         |    2 +
 .../iq/dataverse/util/json/JsonParser.java    |   77 +-
 .../iq/dataverse/util/json/JsonPrinter.java   |  122 +-
 src/main/java/propertyFiles/Bundle.properties |   32 +
 .../migration/V6.X.0.Y-dataset-relations.sql  |   42 +
 .../dataverse/api/DatasetRelationTypesIT.java |  281 ++++
 .../iq/dataverse/api/DatasetRelationsIT.java  | 1306 +++++++++++++++++
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |  141 ++
 .../DatasetRelationIndexingTest.java          |   85 ++
 .../iq/dataverse/engine/PermissionTest.java   |    4 +
 .../dataverse/engine/TestCommandContext.java  |   12 +
 .../export/SchemaDotOrgExporterTest.java      |    4 +-
 .../dataverse/feedback/FeedbackUtilTest.java  |    8 +-
 .../doi/datacite/XmlMetadataTemplateTest.java |   16 +
 .../search/IndexServiceBeanTest.java          |    2 +
 .../dataverse/util/json/JsonParserTest.java   |   24 +-
 .../dataverse/util/json/JsonPrinterTest.java  |   82 +-
 tests/integration-tests.txt                   |    2 +-
 tests/performance/relations/README.md         |   58 +
 tests/performance/relations/cleanup.sh        |   23 +
 tests/performance/relations/cleanup.sql       |   26 +
 tests/performance/relations/explain-list.sql  |  113 ++
 tests/performance/relations/explain.sh        |   27 +
 tests/performance/relations/measure-list.sh   |   80 +
 .../relations/seed-internal-relations.sql     |  143 ++
 tests/performance/relations/seed.sh           |  125 ++
 68 files changed, 5472 insertions(+), 99 deletions(-)
 create mode 100644 scripts/api/data/relationTypes/relationTypeAllFields.json
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/api/dto/DatasetRelationDTO.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelation.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationAlgorithm.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexing.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationServiceBean.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationType.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeException.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeServiceBean.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/ExternalDatasetRelation.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/InternalDatasetRelation.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/datasetrelation/SqlDirectDatasetRelationAlgorithm.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationTypeCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationTypeCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ReplaceDatasetRelationsCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionWithRelationsCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDefaultDatasetRelationTypeCommand.java
 create mode 100644 src/main/resources/db/migration/V6.X.0.Y-dataset-relations.sql
 create mode 100644 src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java
 create mode 100644 src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java
 create mode 100644 src/test/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexingTest.java
 create mode 100644 tests/performance/relations/README.md
 create mode 100755 tests/performance/relations/cleanup.sh
 create mode 100644 tests/performance/relations/cleanup.sql
 create mode 100644 tests/performance/relations/explain-list.sql
 create mode 100755 tests/performance/relations/explain.sh
 create mode 100755 tests/performance/relations/measure-list.sh
 create mode 100644 tests/performance/relations/seed-internal-relations.sql
 create mode 100755 tests/performance/relations/seed.sh

diff --git a/conf/solr/schema.xml b/conf/solr/schema.xml
index 4d65b378485..b9d6f02bbd3 100644
--- a/conf/solr/schema.xml
+++ b/conf/solr/schema.xml
@@ -243,6 +243,7 @@
     <field name="license" type="string" stored="true" indexed="true" multiValued="false"/>
     <field name="fileCount" type="plong" stored="true" indexed="true" multiValued="false"/>
     <field name="datasetCount" type="plong" stored="true" indexed="true" multiValued="false"/>
+    <field name="relatedDatasetCount" type="plong" stored="true" indexed="true" multiValued="false"/>
     
     <!--
         METADATA SCHEMA FIELDS
diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
index c5acafa9af1..2f439fe3f22 100644
--- a/doc/sphinx-guides/source/api/native-api.rst
+++ b/doc/sphinx-guides/source/api/native-api.rst
@@ -2312,6 +2312,8 @@ The optional ``excludeFiles`` parameter specifies whether the files should be li
 
 The optional ``excludeMetadataBlocks`` parameter specifies whether the metadata blocks should be listed in the output (defaults to ``false``).
 
+The optional ``excludeRelations`` parameter specifies whether the dataset's relations should be listed in the output (defaults to ``false``).
+
 
 By default, deaccessioned dataset versions are not included in the search when applying the :latest or :latest-published identifiers. Additionally, when filtering by a specific version tag, you will get a "not found" error if the version is deaccessioned and you do not enable the ``includeDeaccessioned`` option described below.
 
@@ -2847,6 +2849,8 @@ Note that you don't need to edit the top-level fields such as ``versionNumber``,
 
 Now that you've made edits to the metadata in your JSON file, you can send it to a Dataverse installation as described above.
 
+The request also reads an optional ``relations`` array. When present, it replaces the relations defined on the draft; when omitted, existing relations are preserved. Relation objects use the format described under `Dataset relations`_.
+
 .. _edit-dataset-metadata-api:
 
 Edit Dataset Metadata
@@ -2888,7 +2892,7 @@ For these edits your JSON file need only include those dataset fields which you
 
 This endpoint also allows removing fields, as long as they are not required by the dataset. To remove a field, send an empty value (``""``) for individual fields. For multiple fields, send an empty array (``[]``). A sample JSON file for removing fields may be downloaded here: :download:`dataset-edit-metadata-delete-fields-sample.json <../_static/api/dataset-edit-metadata-delete-fields-sample.json>`
 
-If another user updates the dataset version metadata before you send the update request, metadata inconsistencies may occur. To prevent this, you can use the optional ``sourceLastUpdateTime`` query parameter. The intended API workflow is for the client to send along the ``lastUpdateTime`` obtained from the last ``GET`` call on the version that is being modified. Dataverse APIs will always report these time stamps in UTC, ISO 8601-formatted (``yyyy-MM-dd'T'HH:mm:ss'Z'``; for example: ``2026-04-22T14:30:00Z``), regardless of the actual time zone used by the server. This is the only format this API will accept. 
+If another user updates the dataset version metadata before you send the update request, metadata inconsistencies may occur. To prevent this, you can use the optional ``sourceLastUpdateTime`` query parameter. The intended API workflow is for the client to send along the ``lastUpdateTime`` obtained from the last ``GET`` call on the version that is being modified. Dataverse APIs will always report these time stamps in UTC, ISO 8601-formatted (``yyyy-MM-dd'T'HH:mm:ss'Z'``; for example: ``2026-04-22T14:30:00Z``), regardless of the actual time zone used by the server. This is the only format this API will accept.
 
 If this parameter is provided, the update will proceed only if the ``lastUpdateTime`` remains unchanged (meaning no one has updated the dataset metadata since you retrieved it). Otherwise, the request will fail with an error.
 
@@ -2938,7 +2942,7 @@ Update Dataset Terms of Access
 
 Updates the terms of access for the restricted files of a dataset by applying it to the draft version, or by creating a draft if none exists.
 
-If another user updates an already existing draft version before you send the update request, metadata inconsistencies may occur. To prevent this, you can use the optional ``sourceLastUpdateTime`` query parameter. The intended API workflow is for the client to send along the ``lastUpdateTime`` obtained from the last ``GET`` call on the version that is being modified. Dataverse APIs will always report these time stamps in UTC, ISO 8601-formatted (``yyyy-MM-dd'T'HH:mm:ss'Z'``; for example: ``2026-04-22T14:30:00Z``), regardless of the actual time zone used by the server. This is the only format this API will accept. 
+If another user updates an already existing draft version before you send the update request, metadata inconsistencies may occur. To prevent this, you can use the optional ``sourceLastUpdateTime`` query parameter. The intended API workflow is for the client to send along the ``lastUpdateTime`` obtained from the last ``GET`` call on the version that is being modified. Dataverse APIs will always report these time stamps in UTC, ISO 8601-formatted (``yyyy-MM-dd'T'HH:mm:ss'Z'``; for example: ``2026-04-22T14:30:00Z``), regardless of the actual time zone used by the server. This is the only format this API will accept.
 
 If this parameter is provided, the update will proceed only if the ``lastUpdateTime`` remains unchanged (meaning no one has updated the dataset metadata since you retrieved it). Otherwise, the request will fail with an error.
 
@@ -5089,6 +5093,265 @@ The fully expanded example above (without environment variables) looks like this
 
 :download:`list-reviews.json <../_static/api/list-reviews.json>` contains sample output of how the API response might look.
 
+Dataset Relations
+~~~~~~~~~~~~~~~~~
+
+Dataset relations describe how a dataset is related to another Dataverse dataset (an internal relation) or to an external resource.
+
+A relation is represented as JSON. Internal relations use ``relatedDatasetPid`` while external relations use ``externalIdentifier`` and ``identifierScheme``. Both use the name of a configured relation type (see `Dataset Relation Types`_):
+
+.. code-block:: json
+
+  {
+    "relatedDatasetPid": "doi:10.5072/FK2/BBBBBB",
+    "relationType": { "name": "isRelatedTo" }
+  }
+
+An external relation can also include ``relatedDatasetType`` with a ``displayName``:
+
+.. code-block:: json
+
+  {
+    "externalIdentifier": "https://example.org/resource/1",
+    "identifierScheme": "URL",
+    "relatedDatasetType": { "displayName": "Document" },
+    "relationType": { "name": "isRelatedTo" }
+  }
+
+.. note:: See :ref:`curl-examples-and-environment-variables` if you are unfamiliar with the use of ``export`` below.
+
+Add a Dataset Relation
+^^^^^^^^^^^^^^^^^^^^^^
+
+Add a dataset relation. By default this operation affects the latest version, creating a draft when necessary. A superuser can supply the optional ``version`` query parameter to modify a specified published version.
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export PERSISTENT_IDENTIFIER=doi:10.5072/FK2/AAAAAA
+  export SERVER_URL=https://demo.dataverse.org
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -H "Content-Type: application/json" \
+    -X POST "$SERVER_URL/api/datasets/:persistentId/relations?persistentId=$PERSISTENT_IDENTIFIER" \
+    -d '{"relatedDatasetPid":"doi:10.5072/FK2/BBBBBB","relationType":{"name":"isRelatedTo"}}'
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -H "Content-Type: application/json" \
+    -X POST "https://demo.dataverse.org/api/datasets/:persistentId/relations?persistentId=doi:10.5072/FK2/AAAAAA" \
+    -d '{"relatedDatasetPid":"doi:10.5072/FK2/BBBBBB","relationType":{"name":"isRelatedTo"}}'
+
+Replace Dataset Relations
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Bulk replace all relations defined on the selected version with the sent JSON array (including an empty array to remove all relations). By default this operation affects the latest version, creating a draft when necessary. A superuser can supply the optional ``version`` query parameter to modify a specified published version.
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export PERSISTENT_IDENTIFIER=doi:10.5072/FK2/AAAAAA
+  export SERVER_URL=https://demo.dataverse.org
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -H "Content-Type: application/json" \
+    -X PUT "$SERVER_URL/api/datasets/:persistentId/relations?persistentId=$PERSISTENT_IDENTIFIER" \
+    --data-binary @relations.json
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -H "Content-Type: application/json" \
+    -X PUT "https://demo.dataverse.org/api/datasets/:persistentId/relations?persistentId=doi:10.5072/FK2/AAAAAA" \
+    --data-binary @relations.json
+
+List Dataset Relations
+^^^^^^^^^^^^^^^^^^^^^^
+
+List the relations for the latest accessible version (unless the optional ``version`` parameter is supplied). The response is paginated (``limit`` defaults to 10 and ``offset`` defaults to 0). Set ``type``, ``datasetType``, or ``source`` query parameters to filter on one or more relation type names, related dataset type names, or relation sources. Set ``includeMetadataBlocks=true`` to include metadata from related internal datasets. Set ``showFacets=true`` to include relation type and dataset type facets.
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export PERSISTENT_IDENTIFIER=doi:10.5072/FK2/AAAAAA
+  export SERVER_URL=https://demo.dataverse.org
+
+  curl -H "X-Dataverse-key: $API_TOKEN" \
+    "$SERVER_URL/api/datasets/:persistentId/relations?persistentId=$PERSISTENT_IDENTIFIER&version=:draft&type=isRelatedTo&limit=10&offset=0&showFacets=true"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" \
+    "https://demo.dataverse.org/api/datasets/:persistentId/relations?persistentId=doi:10.5072/FK2/AAAAAA&version=:draft&type=isRelatedTo&limit=10&offset=0&showFacets=true"
+
+When requested, facets are returned with the paginated items and total count. The relation type facet applies active dataset type and source filters; the dataset type facet applies active relation type and source filters.
+
+.. code-block:: json
+
+  {
+    "status": "OK",
+    "totalCount": 3,
+    "data": {
+      "items": [],
+      "facets": {
+        "relationType": [
+          {"name": "isRelatedTo", "displayName": "Is related to", "count": 2}
+        ],
+        "datasetType": [
+          {"name": "dataset", "displayName": "Dataset", "count": 3}
+        ]
+      }
+    }
+  }
+
+Get a Dataset Relation
+^^^^^^^^^^^^^^^^^^^^^^
+
+Returns a relation by its database id. It accepts ``includeMetadataBlocks=true``.
+
+.. code-block:: bash
+
+  export PERSISTENT_IDENTIFIER=doi:10.5072/FK2/AAAAAA
+  export SERVER_URL=https://demo.dataverse.org
+  export RELATION_ID=42
+
+  curl "$SERVER_URL/api/datasets/:persistentId/relations/$RELATION_ID?persistentId=$PERSISTENT_IDENTIFIER"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl "https://demo.dataverse.org/api/datasets/:persistentId/relations/42?persistentId=doi:10.5072/FK2/AAAAAA"
+
+Delete a Dataset Relation
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Delete a dataset relation by its database id. Deleting a relation requires permission to edit the dataset on which the relation was originally defined.
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export PERSISTENT_IDENTIFIER=doi:10.5072/FK2/AAAAAA
+  export SERVER_URL=https://demo.dataverse.org
+  export RELATION_ID=42
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -X DELETE \
+    "$SERVER_URL/api/datasets/:persistentId/relations/$RELATION_ID?persistentId=$PERSISTENT_IDENTIFIER"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X DELETE \
+    "https://demo.dataverse.org/api/datasets/:persistentId/relations/42?persistentId=doi:10.5072/FK2/AAAAAA"
+
+Dataset Relation Types
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. note:: See :ref:`curl-examples-and-environment-variables` if you are unfamiliar with the use of ``export`` below.
+
+.. _api-list-dataset-relation-types:
+
+List Dataset Relation Types
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Show which dataset relation types are available.
+
+.. code-block:: bash
+
+  export SERVER_URL=https://demo.dataverse.org
+
+  curl "$SERVER_URL/api/datasets/relationTypes"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl "https://demo.dataverse.org/api/datasets/relationTypes"
+
+.. _api-list-dataset-relation-type:
+
+Get Dataset Relation Type
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Show a dataset relation type by passing either its database id (e.g. "2") or its name (e.g. "isRelatedTo").
+
+.. code-block:: bash
+
+  export SERVER_URL=https://demo.dataverse.org
+  export TYPE=isRelatedTo
+
+  curl $SERVER_URL/api/datasets/relationTypes/$TYPE"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl "https://demo.dataverse.org/api/datasets/relationTypes/isRelatedTo"
+
+.. _api-add-dataset-relation-type:
+
+Add Dataset Relation Type
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Only superusers can add dataset relation types.
+
+Here's an example of all available fields when creating a dataset type:
+
+.. literalinclude:: ../../../../scripts/api/data/relationTypes/relationTypeAllFields.json
+   :language: json
+
+Here's a description of each field:
+
+- ``name`` (required): Machine-readable name.
+- ``displayName`` (required): Human-readable name.
+- ``description``: A description.
+
+The following fields may optionally also be given to add an inverse relationship type:
+
+- ``inverse.name`` (required): Machine-readable name of the inverse relation type. Can be identical to ``name``` if the relation type is the inverse of itself.
+- ``inverse.displayName`` (required): Human-readable name of the inverse relation type.
+- ``inverse.description``: A description of the inverse relation type.
+
+Download the :download:`relationTypeAllFields.json <../../../../scripts/api/data/relationTypes/relationTypeAllFields.json>` file show above, edit it to suit your needs, and use it in the following command.
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -H "Content-Type: application/json" "$SERVER_URL/api/datasets/relationTypes" -X POST --upload-file relationTypeAllFields.json
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -H "Content-Type: application/json" "https://demo.dataverse.org/api/datasets/relationTypes" -X POST --upload-file relationTypeAllFields.json
+
+.. _api-delete-dataset-relation-type:
+
+Delete Dataset Relation Type
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Superuser only. Note that if a dataset relation of this type exists, you will be unable to delete the type until you first use the API to delete that relation.
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export TYPE_ID=3
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X DELETE "$SERVER_URL/api/datasets/relationTypes/$TYPE_ID"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X DELETE "https://demo.dataverse.org/api/datasets/relationTypes/3"
+
 Files
 -----
 
@@ -5880,7 +6143,7 @@ Updating File Metadata
 
 Updates the file metadata for an existing file where ``ID`` is the database id of the file to update or ``PERSISTENT_ID`` is the persistent id (DOI or Handle) of the file. Requires a ``jsonString`` expressing the new metadata. No metadata from the previous version of this file will be persisted, so if you want to update a specific field first get the json with the above command and alter the fields you want.
 
-An optional parameter, ``sourceLastUpdateTime``, can be used to verify that the file metadata being edited has not been changed since you last retrieved it, thereby avoiding potential inconsistencies. In the intended API workflow this will be the time stamp in ``lastUpdateTime`` from the last ``GET /api/files/<id>`` API call. Dataverse APIs will always report these time stamps in UTC, ISO 8601-formatted (``yyyy-MM-dd'T'HH:mm:ss'Z'``; for example: ``2026-04-22T14:30:00Z``), regardless of the actual time zone used by the server. This is the only format this API will accept. 
+An optional parameter, ``sourceLastUpdateTime``, can be used to verify that the file metadata being edited has not been changed since you last retrieved it, thereby avoiding potential inconsistencies. In the intended API workflow this will be the time stamp in ``lastUpdateTime`` from the last ``GET /api/files/<id>`` API call. Dataverse APIs will always report these time stamps in UTC, ISO 8601-formatted (``yyyy-MM-dd'T'HH:mm:ss'Z'``; for example: ``2026-04-22T14:30:00Z``), regardless of the actual time zone used by the server. This is the only format this API will accept.
 
 
 A curl example using an ``ID``
diff --git a/scripts/api/data/relationTypes/relationTypeAllFields.json b/scripts/api/data/relationTypes/relationTypeAllFields.json
new file mode 100644
index 00000000000..e017e757898
--- /dev/null
+++ b/scripts/api/data/relationTypes/relationTypeAllFields.json
@@ -0,0 +1,10 @@
+{
+  "name": "IsSupplementTo",
+  "displayName": "Is supplement to",
+  "description": "Indicates that A is a supplement to B.",
+  "inverse": {
+    "name": "IsSupplementedBy",
+    "displayName": "Is supplemented by",
+    "description": "Indicates that B is a supplement to A."
+  }
+}
\ No newline at end of file
diff --git a/scripts/api/data/role-curator.json b/scripts/api/data/role-curator.json
index 86f18b2ea6a..b68a83d7c08 100644
--- a/scripts/api/data/role-curator.json
+++ b/scripts/api/data/role-curator.json
@@ -5,6 +5,7 @@
     "permissions":[
         "ViewUnpublishedDataset",
         "EditDataset",
+        "EditDatasetRelations",
         "DownloadFile",
         "DeleteDatasetDraft",
         "PublishDataset",
diff --git a/scripts/api/data/role-editor.json b/scripts/api/data/role-editor.json
index 69dd8c8c6ce..c3dc6298917 100644
--- a/scripts/api/data/role-editor.json
+++ b/scripts/api/data/role-editor.json
@@ -5,6 +5,7 @@
     "permissions":[
         "ViewUnpublishedDataset",
         "EditDataset",
+        "EditDatasetRelations",
         "DownloadFile",
         "DeleteDatasetDraft"     
     ]
diff --git a/scripts/api/data/role-manager.json b/scripts/api/data/role-manager.json
index 1105cbf892b..9f14c6f54df 100644
--- a/scripts/api/data/role-manager.json
+++ b/scripts/api/data/role-manager.json
@@ -5,6 +5,7 @@
     "permissions":[
         "ViewUnpublishedDataset",
         "EditDataset",
+        "EditDatasetRelations",
         "DownloadFile",
         "DeleteDatasetDraft"     
     ]
diff --git a/src/main/java/edu/harvard/iq/dataverse/Dataset.java b/src/main/java/edu/harvard/iq/dataverse/Dataset.java
index 39dccdcd4ea..7c9686dd680 100644
--- a/src/main/java/edu/harvard/iq/dataverse/Dataset.java
+++ b/src/main/java/edu/harvard/iq/dataverse/Dataset.java
@@ -3,6 +3,7 @@
 import edu.harvard.iq.dataverse.dataset.DatasetThumbnail;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.dataset.DatasetUtil;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
 import edu.harvard.iq.dataverse.harvest.client.HarvestingClient;
 import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.makedatacount.DatasetExternalCitations;
@@ -360,6 +361,7 @@ public void setVersions(List<DatasetVersion> versions) {
     private DatasetVersion createNewDatasetVersion(Template template, FileMetadata fmVarMet) {
         
         DatasetVersion dsv = new DatasetVersion();
+        dsv.setDataset(this);
         dsv.setVersionState(DatasetVersion.VersionState.DRAFT);
         dsv.setFileMetadatas(new ArrayList<>());
         DatasetVersion latestVersion;
@@ -409,6 +411,14 @@ private DatasetVersion createNewDatasetVersion(Template template, FileMetadata f
                 terms.setFileAccessRequest(true);
                 dsv.setTermsOfUseAndAccess(terms);
             }
+
+            if (latestVersion.getRelations() != null && !latestVersion.getRelations().isEmpty()) {
+                List<DatasetRelation> relations = new ArrayList<>();
+                for (DatasetRelation rel : latestVersion.getRelations()) {
+                    relations.add(rel.copy(dsv));
+                }
+                dsv.setRelations(relations);
+            }
         }
 
         // I'm adding the version to the list so it will be persisted when
@@ -420,7 +430,6 @@ private DatasetVersion createNewDatasetVersion(Template template, FileMetadata f
             getVersions().add(0, dsv);
         }
 
-        dsv.setDataset(this);
         return dsv;
     }
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/DatasetVersion.java b/src/main/java/edu/harvard/iq/dataverse/DatasetVersion.java
index 4bff7150b97..ee99b1a73aa 100644
--- a/src/main/java/edu/harvard/iq/dataverse/DatasetVersion.java
+++ b/src/main/java/edu/harvard/iq/dataverse/DatasetVersion.java
@@ -9,6 +9,7 @@
 import edu.harvard.iq.dataverse.util.json.JsonUtil;
 import edu.harvard.iq.dataverse.util.json.NullSafeJsonBuilder;
 import edu.harvard.iq.dataverse.workflows.WorkflowComment;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
 import jakarta.json.*;
 import jakarta.persistence.*;
 import jakarta.validation.ConstraintViolation;
@@ -101,7 +102,7 @@ public enum VersionState {
     public static final String ARCHIVAL_STATUS_SUCCESS = "success";
     public static final String ARCHIVAL_STATUS_FAILURE = "failure";
     public static final String ARCHIVAL_STATUS_OBSOLETE = "obsolete";
-    
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -201,12 +202,23 @@ public enum VersionState {
     private DatasetVersionDifference dvd;
     
     //The Json version of the archivalCopyLocation string
-    @Transient 
+    @Transient
     private JsonObject archivalCopyLocationJson;
 
     @Transient
     private Boolean hasFiles = null;
     
+    @OneToMany(mappedBy = "definitionPoint", cascade = {CascadeType.REMOVE, CascadeType.MERGE, CascadeType.PERSIST}, orphanRemoval = true)
+    private List<DatasetRelation> relations;
+
+    public List<DatasetRelation> getRelations() {
+        return relations;
+    }
+
+    public void setRelations(List<DatasetRelation> relations) {
+        this.relations = relations;
+    }
+
     public Long getId() {
         return this.id;
     }
@@ -703,6 +715,15 @@ public DatasetVersion cloneDatasetVersion(){
             }
 
         dsv.setDataset(this.getDataset());
+
+        if (this.getRelations() != null && !this.getRelations().isEmpty()) {
+            List<DatasetRelation> clonedRelations = new ArrayList<>();
+            for (DatasetRelation r : this.getRelations()) {
+                clonedRelations.add(r.copy(dsv));
+            }
+            dsv.setRelations(clonedRelations);
+        }
+
         return dsv;
     }
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/DatasetVersionDifference.java b/src/main/java/edu/harvard/iq/dataverse/DatasetVersionDifference.java
index fd52e0c4df4..f85db5d4af9 100644
--- a/src/main/java/edu/harvard/iq/dataverse/DatasetVersionDifference.java
+++ b/src/main/java/edu/harvard/iq/dataverse/DatasetVersionDifference.java
@@ -3,7 +3,9 @@
 import edu.harvard.iq.dataverse.datavariable.DataVariable;
 import edu.harvard.iq.dataverse.datavariable.VarGroup;
 import edu.harvard.iq.dataverse.datavariable.VariableMetadataUtil;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
 import edu.harvard.iq.dataverse.util.StringUtil;
+import edu.harvard.iq.dataverse.util.json.JsonPrinter;
 
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
@@ -47,6 +49,8 @@ public final class DatasetVersionDifference {
     private List<FileMetadata> changedVariableMetadata = new ArrayList<>();
     private List<FileMetadata[]> replacedFiles = new ArrayList<>();
     private List<String[]> changedTermsAccess = new ArrayList<>();
+    private List<DatasetRelation> addedRelations = new ArrayList<>();
+    private List<DatasetRelation> removedRelations = new ArrayList<>();
     private List<SummaryNote> summaryDataForNote = new ArrayList<>();
     private List<SummaryNote> blockDataForNote = new ArrayList<>();
 
@@ -179,6 +183,7 @@ public DatasetVersionDifference(DatasetVersion newVersion, DatasetVersion origin
         
         logger.fine("Main difference loop execution time: " + (System.currentTimeMillis() - startTime) + " ms");
         initDatasetFilesDifferencesList();
+        getRelationDifferences();
 
         //Sort within blocks by datasetfieldtype display order
         for (List<DatasetField[]> blockList : detailDataByBlock) {
@@ -210,6 +215,24 @@ public DatasetVersionDifference(DatasetVersion newVersion, DatasetVersion origin
         });
         getTermsDifferences();
     }
+
+    private void getRelationDifferences() {
+        Map<String, DatasetRelation> originalRelations = new HashMap<>();
+        List<DatasetRelation> originalVersionRelations = originalVersion.getRelations() == null
+                ? Collections.emptyList() : originalVersion.getRelations();
+        for (DatasetRelation relation : originalVersionRelations) {
+            originalRelations.put(relation.toVersionComparisonKey(), relation);
+        }
+
+        List<DatasetRelation> newVersionRelations = newVersion.getRelations() == null
+                ? Collections.emptyList() : newVersion.getRelations();
+        for (DatasetRelation relation : newVersionRelations) {
+            if (originalRelations.remove(relation.toVersionComparisonKey()) == null) {
+                addedRelations.add(relation);
+            }
+        }
+        removedRelations.addAll(originalRelations.values());
+    }
     
 
        
@@ -1724,6 +1747,7 @@ public JsonObjectBuilder getSummaryDifferenceAsJson(){
         }   
         
         jobVersion.add("files", getFileSummaryAsJson());
+        jobVersion.add("relations", getRelationsSummaryAsJson());
         
         if (!this.changedTermsAccess.isEmpty()) {
             jobVersion.add("termsAccessChanged", true);
@@ -1733,6 +1757,13 @@ public JsonObjectBuilder getSummaryDifferenceAsJson(){
                 
         return jobVersion;
     }
+
+    private JsonObjectBuilder getRelationsSummaryAsJson() {
+        JsonObjectBuilder job = new NullSafeJsonBuilder();
+        job.add("added", addedRelations.size());
+        job.add("removed", removedRelations.size());
+        return job;
+    }
     
     private JsonObjectBuilder getSummaryNoteAsJson(SummaryNote sn){
         JsonObjectBuilder job = new NullSafeJsonBuilder();
@@ -1870,6 +1901,13 @@ public JsonObjectBuilder compareVersionsAsJson() {
             job.add("fileChanges", jabDiffFiles);
         }
 
+        if (!addedRelations.isEmpty()) {
+            job.add("relationsAdded", JsonPrinter.json(addedRelations, newVersion.getDataset(), false));
+        }
+        if (!removedRelations.isEmpty()) {
+            job.add("relationsRemoved", JsonPrinter.json(removedRelations, originalVersion.getDataset(), false));
+        }
+
         // Format Terms Of Access changes
         if (!changedTermsAccess.isEmpty()) {
             JsonObjectBuilder jobTOA = new NullSafeJsonBuilder();
diff --git a/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java b/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
index 4fa85a543d8..64bd1fb5a7a 100644
--- a/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
+++ b/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
@@ -5,6 +5,8 @@
 import edu.harvard.iq.dataverse.dataset.DatasetFieldsValidator;
 import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
 import edu.harvard.iq.dataverse.authorization.providers.builtin.BuiltinUserServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationTypeServiceBean;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.license.LicenseServiceBean;
 import edu.harvard.iq.dataverse.util.cache.CacheFactoryBean;
@@ -140,6 +142,12 @@ public class EjbDataverseEngine {
     @EJB
     DatasetTypeServiceBean datasetTypeService;
 
+    @EJB
+    DatasetRelationServiceBean datasetRelationService;
+
+    @EJB
+    DatasetRelationTypeServiceBean datasetRelationTypeService;
+
     @EJB
     DataverseLinkingServiceBean dvLinking;
     
@@ -665,6 +673,16 @@ public DatasetTypeServiceBean datasetTypes() {
                     return datasetTypeService;
                 }
 
+                @Override
+                public DatasetRelationServiceBean datasetRelations() {
+                    return datasetRelationService;
+                }
+
+                @Override
+                public DatasetRelationTypeServiceBean datasetRelationTypes() {
+                    return datasetRelationTypeService;
+                }
+
                 @Override
                 public void beginCommandSequence() {
                     this.commandsCalled = new Stack();
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
index b32b5ae8d49..8417f507134 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
@@ -13,7 +13,12 @@
 import edu.harvard.iq.dataverse.authorization.users.User;
 import edu.harvard.iq.dataverse.confirmemail.ConfirmEmailServiceBean;
 import edu.harvard.iq.dataverse.datacapturemodule.DataCaptureModuleServiceBean;
-import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
+import edu.harvard.iq.dataverse.dataset.*;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationTypeServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.InternalDatasetRelation;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
 import edu.harvard.iq.dataverse.engine.command.Command;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
@@ -59,15 +64,19 @@
 import jakarta.ws.rs.core.Response;
 import jakarta.ws.rs.core.Response.ResponseBuilder;
 import jakarta.ws.rs.core.Response.Status;
+import org.apache.commons.lang3.StringUtils;
 
 import java.io.InputStream;
 import java.net.URI;
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.*;
 import java.util.concurrent.Callable;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import static edu.harvard.iq.dataverse.util.json.JsonPrinter.json;
+import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
 import static org.apache.commons.lang3.StringUtils.isNumeric;
 
 /**
@@ -175,6 +184,12 @@ String getWrappedMessageWhenJson() {
     @EJB
     protected DatasetTypeServiceBean datasetTypeSvc;
 
+    @EJB
+    protected DatasetRelationServiceBean datasetRelationSvc;
+
+    @EJB
+    protected DatasetRelationTypeServiceBean datasetRelationTypeSvc;
+
     @EJB
     protected UserServiceBean userSvc;
 
@@ -267,7 +282,7 @@ public enum Format {
     private final LazyRef<JsonParser> jsonParserRef = new LazyRef<>(new Callable<JsonParser>() {
         @Override
         public JsonParser call() throws Exception {
-            return new JsonParser(datasetFieldSvc, metadataBlockSvc,settingsSvc, licenseSvc, datasetTypeSvc, templateSvc);
+            return new JsonParser(datasetFieldSvc, metadataBlockSvc,settingsSvc, licenseSvc, datasetTypeSvc, templateSvc, datasetRelationSvc);
         }
     });
 
@@ -531,6 +546,70 @@ public Command<DatasetVersion> handleLatestPublished() {
         return dsv;
     }
 
+    protected DatasetRelation findDatasetRelationOrDie(String relationId, String datasetId, boolean strict) throws WrappedResponse {
+        Dataset dataset = findDatasetOrDie(datasetId);
+
+        long relationIdAsLong;
+        try {
+            relationIdAsLong = Long.parseLong(relationId);
+        } catch (NumberFormatException e) {
+            throw new WrappedResponse(
+                    badRequest(BundleUtil.getStringFromBundle("find.datasetrelation.error.datasetrelation.not.found.bad.id", Collections.singletonList(relationId))));
+        }
+
+        DatasetRelation relation = datasetRelationSvc.getDatasetRelationById(relationIdAsLong);
+
+        if (relation == null) {
+            throw new WrappedResponse(
+                    notFound(BundleUtil.getStringFromBundle("find.datasetrelation.error.datasetrelation.not.found.id", Collections.singletonList(relationId))));
+        }
+
+        // Generally, the relation must involve the given dataset
+        boolean relationMatchesDataset = relation.getDataset().equals(dataset);
+        if (relation instanceof InternalDatasetRelation internalRelation) {
+            relationMatchesDataset = relationMatchesDataset || internalRelation.getRelatedDataset().equals(dataset);
+        }
+        // If we are strict matching (used during relation deletion), the relation must also be defined on the given dataset
+        if (strict) {
+            relationMatchesDataset = relationMatchesDataset && relation.getDefinitionPoint().getDataset().equals(dataset);
+        }
+
+        if (!relationMatchesDataset) {
+            throw new WrappedResponse(
+                    notFound(BundleUtil.getStringFromBundle("find.datasetrelation.error.datasetrelation.not.found.id", Collections.singletonList(relationId))));
+        }
+
+        return relation;
+    }
+
+    protected DatasetRelationType findDatasetRelationTypeOrDie(String idOrName) throws WrappedResponse {
+        DatasetRelationType drt;
+
+        if (idOrName == null || idOrName.isEmpty()) {
+            throw new WrappedResponse(
+                    badRequest(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.idRequired")));
+        }
+
+        if (StringUtils.isNumeric(idOrName)) {
+            try {
+                long id = Long.parseLong(idOrName);
+                drt = datasetRelationTypeSvc.findById(id);
+            } catch (NumberFormatException ex) {
+                throw new WrappedResponse(
+                        badRequest(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.idMustBeNumber")));
+            }
+        } else {
+            drt = datasetRelationTypeSvc.findByName(idOrName);
+        }
+
+        if (drt == null) {
+            throw new WrappedResponse(
+                    notFound(MessageFormat.format(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.notFound"), idOrName)));
+        }
+
+        return drt;
+    }
+
     protected void validateInternalTimestampIsNotOutdated(DvObject dvObject, String sourceLastUpdateTime) throws WrappedResponse {
         // The timestamp string must always be in UTC, ISO 8601-formatted
         // for example: 2026-04-22T14:30:00Z. This is explicitly specified in the
@@ -1039,9 +1118,9 @@ protected Response ok(JsonValue value, JsonValue message, Long totalCount) {
                 .build())
             .type(MediaType.APPLICATION_JSON)
             .build();
-    
+
     }
-    
+
     protected Response ok(JsonArrayBuilder bld) {
         return ok(bld.build(), null, null);
     }
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java b/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java
new file mode 100644
index 00000000000..fad496e8352
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java
@@ -0,0 +1,321 @@
+package edu.harvard.iq.dataverse.api;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import edu.harvard.iq.dataverse.api.auth.AuthRequired;
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.authorization.users.User;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.engine.command.impl.CreateDatasetRelationCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.CreateDatasetRelationTypeCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.DeleteDatasetRelationCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.DeleteDatasetRelationTypeCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.GetLatestAccessibleDatasetVersionCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.ReplaceDatasetRelationsCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.UpdateDatasetVersionCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.UpdateDefaultDatasetRelationTypeCommand;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import edu.harvard.iq.dataverse.util.json.JsonParseException;
+import edu.harvard.iq.dataverse.util.json.JsonUtil;
+import edu.harvard.iq.dataverse.util.json.NullSafeJsonBuilder;
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonObjectBuilder;
+import jakarta.json.JsonValue;
+import jakarta.json.stream.JsonParsingException;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response.Status;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static edu.harvard.iq.dataverse.util.json.JsonPrinter.json;
+import static edu.harvard.iq.dataverse.util.json.JsonPrinter.toJsonArray;
+
+/** API resource for dataset relations and dataset relation types. */
+@Path("datasets")
+public class DatasetRelations extends AbstractApiBean {
+
+    private static final Logger logger = Logger.getLogger(DatasetRelations.class.getCanonicalName());
+
+    @PUT
+    @AuthRequired
+    @Path("{identifier}/relations")
+    public Response replaceDatasetRelations(@Context ContainerRequestContext crc, String body,
+            @PathParam("identifier") String id, @QueryParam("version") String versionNumber) {
+        return response(req -> {
+            try {
+                Dataset dataset = findDatasetOrDie(id);
+                DatasetVersion version = editableVersionOrResponse(req, crc, dataset, versionNumber);
+                if (version == null) {
+                    return forbidden(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.editForbidden"));
+                }
+                List<DatasetRelationDTO> relations = parseReplaceRequest(body);
+                List<DatasetRelation> replaced = execCommand(new ReplaceDatasetRelationsCommand(version, relations, req,
+                        versionNumber != null));
+                return ok(replaced.stream().map(relation -> json(relation, dataset, false)).collect(toJsonArray()));
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            } catch (JsonParsingException ex) {
+                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.jsonparse"), ex.getMessage()));
+            } catch (JsonParseException ex) {
+                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.jsonparsetodatasetrelation"), ex.getMessage()));
+            }
+        }, getRequestUser(crc));
+    }
+
+    @POST
+    @AuthRequired
+    @Path("{identifier}/relations")
+    public Response createSingleDatasetRelation(@Context ContainerRequestContext crc, String body,
+            @PathParam("identifier") String id, @QueryParam("version") String versionNumber) {
+        return response(req -> {
+            try {
+                DatasetRelationDTO relation = parseAddRequest(body);
+                Dataset dataset = findDatasetOrDie(id);
+                DatasetVersion version;
+                if (versionNumber != null) {
+                    version = editableVersionOrResponse(req, crc, dataset, versionNumber);
+                    if (version == null) {
+                        return forbidden(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.editForbidden"));
+                    }
+                } else {
+                    boolean updateDraft = dataset.getLatestVersion().isDraft();
+                    version = dataset.getOrCreateEditVersion();
+                    if (!updateDraft) {
+                        dataset = execCommand(new UpdateDatasetVersionCommand(dataset, req));
+                        version = dataset.getLatestVersion();
+                    }
+                }
+                DatasetRelation created = execCommand(new CreateDatasetRelationCommand(version, relation, req));
+                return ok(json(created, dataset, false));
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            } catch (JsonParsingException ex) {
+                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.jsonparse"), ex.getMessage()));
+            } catch (JsonParseException ex) {
+                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.jsonparsetodatasetrelation"), ex.getMessage()));
+            }
+        }, getRequestUser(crc));
+    }
+
+    @GET
+    @AuthRequired
+    @Path("{identifier}/relations/{id}")
+    public Response getSingleRelation(@Context ContainerRequestContext crc, @PathParam("identifier") String datasetId,
+            @PathParam("id") String id, @QueryParam("includeMetadataBlocks") boolean includeMetadataBlocks) {
+        return response(req -> {
+            User user = getRequestUser(crc);
+            Dataset dataset = findDatasetOrDie(datasetId);
+            DatasetRelation relation = findDatasetRelationOrDie(id, datasetId, false);
+            if (!relation.getDefinitionPoint().isReleased() && !permissionSvc.hasPermissionsFor(user,
+                    relation.getDefinitionPoint().getDataset(), EnumSet.of(Permission.ViewUnpublishedDataset))) {
+                return forbidden(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.viewForbidden"));
+            }
+            return ok(json(relation, dataset, includeMetadataBlocks));
+        }, getRequestUser(crc));
+    }
+
+    @DELETE
+    @AuthRequired
+    @Path("{identifier}/relations/{id}")
+    public Response deleteSingleRelation(@Context ContainerRequestContext crc, @PathParam("identifier") String datasetId,
+            @PathParam("id") String id) {
+        return response(req -> {
+            try {
+                DatasetRelation relation = findDatasetRelationOrDie(id, datasetId, true);
+                execCommand(new DeleteDatasetRelationCommand(req, relation));
+                return ok(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.delete.success"));
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            }
+        }, getRequestUser(crc));
+    }
+
+    @GET
+    @AuthRequired
+    @Path("{identifier}/relations")
+    public Response listRelations(@Context ContainerRequestContext crc, @PathParam("identifier") String id,
+            @QueryParam("includeMetadataBlocks") boolean includeMetadataBlocks, @QueryParam("limit") Integer limit,
+            @QueryParam("offset") Integer offset, @QueryParam("type") List<String> relationTypeNames,
+            @QueryParam("datasetType") List<String> datasetTypeNames, @QueryParam("source") List<String> relationSources,
+            @QueryParam("version") String versionNumber, @QueryParam("showFacets") boolean showFacets) {
+        return response(req -> {
+            try {
+                Dataset dataset = findDatasetOrDie(id);
+                DatasetVersion version = accessibleVersionOrResponse(req, dataset, versionNumber);
+                if (version == null) {
+                    return notFound(MessageFormat.format(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.datasetVersionNotFound"), dataset.getGlobalId().asString()));
+                }
+                int effectiveLimit = limit != null ? limit : 10;
+                int effectiveOffset = offset != null ? offset : 0;
+                List<DatasetRelation> relations = datasetRelationSvc.getDatasetRelationsFor(dataset, version, relationTypeNames,
+                        datasetTypeNames, relationSources, effectiveLimit, effectiveOffset);
+                long totalCount = datasetRelationSvc.getTotalDatasetRelationCountFor(dataset, version, relationTypeNames,
+                        datasetTypeNames, relationSources);
+                JsonObjectBuilder data = Json.createObjectBuilder()
+                        .add("items", json(relations, dataset, includeMetadataBlocks));
+                if (showFacets) {
+                    data.add("facets", Json.createObjectBuilder()
+                            // A facet omits its own filter so clients can offer alternative values.
+                            .add("relationType", jsonFacetCounts(datasetRelationSvc.getDatasetRelationFacetCountsFor(dataset, version,
+                                    "relationType", null, datasetTypeNames, relationSources)))
+                            .add("datasetType", jsonFacetCounts(datasetRelationSvc.getDatasetRelationFacetCountsFor(dataset, version,
+                                    "datasetType", relationTypeNames, null, relationSources))));
+                }
+                return Response.ok(Json.createObjectBuilder()
+                        .add("status", ApiConstants.STATUS_OK)
+                        .add("data", data)
+                        .add("totalCount", totalCount)
+                        .build()).type("application/json").build();
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            }
+        }, getRequestUser(crc));
+    }
+
+    private JsonArray jsonFacetCounts(List<Object[]> counts) {
+        return counts.stream().map(count -> new NullSafeJsonBuilder()
+                .add("name", count[0] != null ? count[0].toString() : null)
+                .add("displayName", count[1] != null ? count[1].toString() : null)
+                .add("description", count[2] != null ? count[2].toString() : null)
+                .add("count", ((Number) count[3]).longValue()))
+                .collect(toJsonArray()).build();
+    }
+
+    @POST
+    @AuthRequired
+    @Path("relationTypes")
+    public Response addRelationType(@Context ContainerRequestContext crc, String jsonIn) {
+        return response(req -> {
+            JsonObject relationTypeJson = JsonUtil.getJsonObject(jsonIn);
+            DatasetRelationType relationType = new DatasetRelationType(relationTypeJson.getString("name", null),
+                    relationTypeJson.getString("displayName", null), relationTypeJson.getString("description", null));
+            if (relationTypeJson.containsKey("inverse") && relationTypeJson.get("inverse").getValueType() == JsonValue.ValueType.OBJECT) {
+                JsonObject inverse = relationTypeJson.getJsonObject("inverse");
+                String inverseName = inverse.getString("name", null);
+                if (inverseName != null && !inverseName.isEmpty()) {
+                    if (inverseName.equals(relationType.getName())) {
+                        relationType.setInverse(relationType);
+                    } else {
+                        new DatasetRelationType(inverseName, inverse.getString("displayName", null),
+                                inverse.getString("description", null), relationType);
+                    }
+                }
+            }
+            try {
+                execCommand(new CreateDatasetRelationTypeCommand(req, relationType));
+                return ok(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.create.success"));
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            }
+        }, getRequestUser(crc));
+    }
+
+    @DELETE
+    @AuthRequired
+    @Path("relationTypes/{idOrName}")
+    public Response deleteRelationType(@Context ContainerRequestContext crc, @PathParam("idOrName") String idOrName) {
+        return response(req -> {
+            try {
+                execCommand(new DeleteDatasetRelationTypeCommand(req, findDatasetRelationTypeOrDie(idOrName)));
+                return ok(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.delete.success"));
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            }
+        }, getRequestUser(crc));
+    }
+
+    @GET
+    @Path("relationTypes")
+    public Response getRelationTypes() {
+        return ok(datasetRelationTypeSvc.listAll().stream().map(type -> json(type)).collect(toJsonArray()));
+    }
+
+    @GET
+    @Path("relationTypes/{idOrName}")
+    public Response getRelationType(@PathParam("idOrName") String idOrName) {
+        try {
+            return ok(json(findDatasetRelationTypeOrDie(idOrName)));
+        } catch (WrappedResponse ex) {
+            return ex.getResponse();
+        }
+    }
+
+    @GET
+    @Path("relationTypes/defaultRelationType")
+    public Response getDefaultRelationType() {
+        DatasetRelationType relationType = datasetRelationTypeSvc.getDefault();
+        return relationType == null
+                ? notFound(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.default.notFound"))
+                : ok(json(relationType));
+    }
+
+    @PUT
+    @AuthRequired
+    @Path("relationTypes/defaultRelationType/{idOrName}")
+    public Response setDefaultRelationType(@Context ContainerRequestContext crc, @PathParam("idOrName") String idOrName) {
+        return response(req -> {
+            try {
+                execCommand(new UpdateDefaultDatasetRelationTypeCommand(req, findDatasetRelationTypeOrDie(idOrName)));
+                return ok(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.default.success"));
+            } catch (WrappedResponse ex) {
+                return ex.getResponse();
+            }
+        }, getRequestUser(crc));
+    }
+
+    private DatasetVersion editableVersionOrResponse(edu.harvard.iq.dataverse.engine.command.DataverseRequest request,
+            ContainerRequestContext crc, Dataset dataset, String versionNumber) throws WrappedResponse {
+        if (versionNumber == null) {
+            return dataset.getLatestVersion();
+        }
+        return getRequestUser(crc).isSuperuser()
+                ? findDatasetVersionOrDie(request, versionNumber, dataset, false, false) : null;
+    }
+
+    private DatasetVersion accessibleVersionOrResponse(edu.harvard.iq.dataverse.engine.command.DataverseRequest request,
+            Dataset dataset, String versionNumber) throws WrappedResponse {
+        return versionNumber != null ? findDatasetVersionOrDie(request, versionNumber, dataset, false, false)
+                : execCommand(new GetLatestAccessibleDatasetVersionCommand(request, dataset, false, false));
+    }
+
+    private List<DatasetRelationDTO> parseReplaceRequest(String body) throws JsonParsingException, JsonParseException {
+        try {
+            List<DatasetRelationDTO> relations = new ArrayList<>();
+            JsonArray json = JsonUtil.getJsonArray(body);
+            for (JsonObject relation : json.getValuesAs(JsonObject.class)) {
+                relations.add(jsonParser().parseDatasetRelationDTO(relation));
+            }
+            return relations;
+        } catch (JsonParsingException ex) {
+            logger.log(Level.SEVERE, "Json: {0}", body);
+            throw ex;
+        }
+    }
+
+    private DatasetRelationDTO parseAddRequest(String body) throws JsonParsingException, JsonParseException {
+        try {
+            return jsonParser().parseDatasetRelationDTO(JsonUtil.getJsonObject(body));
+        } catch (JsonParsingException ex) {
+            logger.log(Level.SEVERE, "Json: {0}", body);
+            throw ex;
+        }
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Datasets.java b/src/main/java/edu/harvard/iq/dataverse/api/Datasets.java
index 1b549b10a6b..a5d47075af8 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Datasets.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Datasets.java
@@ -4,9 +4,7 @@
 import edu.harvard.iq.dataverse.DatasetLock.Reason;
 import edu.harvard.iq.dataverse.actionlogging.ActionLogRecord;
 import edu.harvard.iq.dataverse.api.auth.AuthRequired;
-import edu.harvard.iq.dataverse.api.dto.CustomTermsDTO;
-import edu.harvard.iq.dataverse.api.dto.LicenseUpdateRequest;
-import edu.harvard.iq.dataverse.api.dto.RoleAssignmentDTO;
+import edu.harvard.iq.dataverse.api.dto.*;
 import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
 import edu.harvard.iq.dataverse.authorization.DataverseRole;
 import edu.harvard.iq.dataverse.authorization.Permission;
@@ -19,10 +17,7 @@
 import edu.harvard.iq.dataverse.dataaccess.*;
 import edu.harvard.iq.dataverse.datacapturemodule.DataCaptureModuleUtil;
 import edu.harvard.iq.dataverse.datacapturemodule.ScriptRequestResponse;
-import edu.harvard.iq.dataverse.dataset.DatasetThumbnail;
-import edu.harvard.iq.dataverse.dataset.DatasetType;
-import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
-import edu.harvard.iq.dataverse.dataset.DatasetUtil;
+import edu.harvard.iq.dataverse.dataset.*;
 import edu.harvard.iq.dataverse.datasetutility.AddReplaceFileHelper;
 import edu.harvard.iq.dataverse.datasetutility.DataFileTagException;
 import edu.harvard.iq.dataverse.datasetutility.NoFilesException;
@@ -69,6 +64,7 @@
 import jakarta.inject.Inject;
 import jakarta.json.*;
 import jakarta.json.stream.JsonParsingException;
+import jakarta.persistence.PersistenceException;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import jakarta.ws.rs.*;
@@ -531,6 +527,7 @@ public Response getVersion(@Context ContainerRequestContext crc,
                                @Parameter(description = "Resource id or persistent identifier.") @PathParam("id") String datasetId,
                                @Parameter(description = "Dataset version selector.") @PathParam("versionId") String versionId,
                                @Parameter(description = "Whether files are excluded from the returned dataset version metadata.") @QueryParam("excludeFiles") Boolean excludeFiles,
+                               @Parameter(description = "Whether relations are excluded from the returned dataset version metadata.") @QueryParam("excludeRelations") Boolean excludeRelations,
                                @Parameter(description = "Whether metadata blocks are excluded from the returned dataset version metadata.") @QueryParam("excludeMetadataBlocks") Boolean excludeMetadataBlocks,
                                @Parameter(description = "Whether deaccessioned dataset versions are included.") @QueryParam("includeDeaccessioned") boolean includeDeaccessioned,
                                @Parameter(description = "Whether owner information is included in the response.") @QueryParam("returnOwners") boolean returnOwners,
@@ -540,6 +537,7 @@ public Response getVersion(@Context ContainerRequestContext crc,
         return response( req -> {
             boolean includeMetadataBlocks = excludeMetadataBlocks == null ? true : !excludeMetadataBlocks;
             boolean includeFiles = excludeFiles == null ? true : !excludeFiles;
+            boolean includeRelations = excludeRelations == null ? true : !excludeRelations;
             boolean ignoreSettingExcludeEmailFromExport = ignoreSettingToExcludeEmailFromExport != null ? ignoreSettingToExcludeEmailFromExport : false;
 
             //If excludeFiles is null the default is to provide the files and because of this we need to check permissions.
@@ -568,7 +566,7 @@ public Response getVersion(@Context ContainerRequestContext crc,
                 ignoreSettingExcludeEmailFromExport = false;
             }
 
-            JsonObjectBuilder jsonBuilder = json(requestedDatasetVersion, null, includeFiles,
+            JsonObjectBuilder jsonBuilder = json(requestedDatasetVersion, null, includeFiles, includeRelations,
                     returnOwners, includeMetadataBlocks, false, ignoreSettingExcludeEmailFromExport);
             return ok(jsonBuilder);
 
@@ -916,7 +914,10 @@ public Response updateDraftVersion(@Context ContainerRequestContext crc,
             DataverseRequest req = createDataverseRequest(getRequestUser(crc));
             Dataset ds = findDatasetOrDie(id);
             JsonObject json = JsonUtil.getJsonObject(jsonBody);
-            DatasetVersion incomingVersion = jsonParser().parseDatasetVersion(json);
+            List<DatasetRelationDTO> relationDTOs = jsonParser().parseDatasetRelationDTOs(json);
+            DatasetVersion incomingVersion = new DatasetVersion();
+            incomingVersion.setDataset(ds);
+            incomingVersion = jsonParser().parseDatasetVersion(json, incomingVersion);
 
             // clear possibly stale fields from the incoming dataset version.
             // creation and modification dates are updated by the commands.
@@ -928,31 +929,17 @@ public Response updateDraftVersion(@Context ContainerRequestContext crc,
             incomingVersion.setCreateTime(null);
             incomingVersion.setLastUpdateTime(null);
 
+            if (relationDTOs != null
+                    && !permissionSvc.permissionsFor(req, ds).contains(Permission.EditDatasetRelations)) {
+                return unauthorized(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.editNotAuthorized"));
+            }
+
             if (!incomingVersion.getFileMetadatas().isEmpty()){
                 return error( Response.Status.BAD_REQUEST, "You may not add files via this api.");
             }
 
-            boolean updateDraft = ds.getLatestVersion().isDraft();
-
-            DatasetVersion managedVersion;
-            if (updateDraft) {
-                final DatasetVersion editVersion = ds.getOrCreateEditVersion();
-                editVersion.setDatasetFields(incomingVersion.getDatasetFields());
-                editVersion.setTermsOfUseAndAccess(incomingVersion.getTermsOfUseAndAccess());
-                editVersion.getTermsOfUseAndAccess().setDatasetVersion(editVersion);
-                boolean hasValidTerms = TermsOfUseAndAccessValidator.isTOUAValid(editVersion.getTermsOfUseAndAccess(), null);
-                if (!hasValidTerms) {
-                    return error(Status.CONFLICT, BundleUtil.getStringFromBundle("dataset.message.toua.invalid"));
-                }
-                Dataset managedDataset = execCommand(new UpdateDatasetVersionCommand(ds, req));
-                managedVersion = managedDataset.getOrCreateEditVersion();
-            } else {
-                boolean hasValidTerms = TermsOfUseAndAccessValidator.isTOUAValid(incomingVersion.getTermsOfUseAndAccess(), null);
-                if (!hasValidTerms) {
-                    return error(Status.CONFLICT, BundleUtil.getStringFromBundle("dataset.message.toua.invalid"));
-                }
-                managedVersion = execCommand(new CreateDatasetVersionCommand(req, ds, incomingVersion));
-            }
+            DatasetVersion managedVersion = execCommand(
+                    new UpdateDatasetVersionWithRelationsCommand(ds, incomingVersion, relationDTOs, req));
             return ok( json(managedVersion, true) );
 
         } catch (JsonParseException ex) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/DatasetRelationDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/DatasetRelationDTO.java
new file mode 100644
index 00000000000..9cc2d91ffa4
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/DatasetRelationDTO.java
@@ -0,0 +1,59 @@
+package edu.harvard.iq.dataverse.api.dto;
+
+/**
+ * Data Transfer Object (DTO) representing a dataset relation.
+ * This class encapsulates the information required to describe a relationship between datasets.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+public class DatasetRelationDTO {
+    private String relationTypeName;
+
+    // For internal dataset relations
+    private String relatedDatasetPid;
+
+    // For external dataset relations
+    private String externalIdentifier;
+    private String identifierScheme;
+    private String datasetType;
+
+    public String getRelatedDatasetPid() {
+        return relatedDatasetPid;
+    }
+
+    public void setRelatedDatasetPid(String relatedDatasetPid) {
+        this.relatedDatasetPid = relatedDatasetPid;
+    }
+
+    public String getExternalIdentifier() {
+        return externalIdentifier;
+    }
+
+    public void setExternalIdentifier(String externalIdentifier) {
+        this.externalIdentifier = externalIdentifier;
+    }
+
+    public String getIdentifierScheme() {
+        return identifierScheme;
+    }
+
+    public void setIdentifierScheme(String identifierScheme) {
+        this.identifierScheme = identifierScheme;
+    }
+
+    public String getRelationTypeName() {
+        return relationTypeName;
+    }
+
+    public void setRelationTypeName(String relationTypeName) {
+        this.relationTypeName = relationTypeName;
+    }
+
+    public String getDatasetType() {
+        return datasetType;
+    }
+
+    public void setDatasetType(String datasetType) {
+        this.datasetType = datasetType;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java
index ebed6330f2b..30c99fbda0e 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java
@@ -6,7 +6,10 @@
 import edu.harvard.iq.dataverse.api.dto.*;
 import edu.harvard.iq.dataverse.api.dto.FieldDTO;
 import edu.harvard.iq.dataverse.api.dto.MetadataBlockDTO;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
 import edu.harvard.iq.dataverse.license.LicenseServiceBean;
 import edu.harvard.iq.dataverse.pidproviders.doi.AbstractDOIProvider;
 import edu.harvard.iq.dataverse.pidproviders.handle.HandlePidProvider;
@@ -75,6 +78,9 @@ public class ImportGenericServiceBean {
     @EJB
     TemplateServiceBean templateService;
 
+    @EJB
+    DatasetRelationServiceBean datasetRelationService;
+
     @PersistenceContext(unitName = "VDCNet-ejbPU")
     private EntityManager em;
     
@@ -110,7 +116,12 @@ public void importXML(String xmlToParse, String foreignFormat, DatasetVersion da
             String json = gson.toJson(datasetDTO.getDatasetVersion());
             logger.fine(json);
             JsonObject obj = JsonUtil.getJsonObject(json);
-            DatasetVersion dv = new JsonParser(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, templateService).parseDatasetVersion(obj, datasetVersion);
+            JsonParser parser = new JsonParser(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+            DatasetVersion dv = parser.parseDatasetVersion(obj, datasetVersion);
+            List<DatasetRelation> relations = parser.parseDatasetRelations(obj, dv);
+            if (relations != null) {
+                dv.setRelations(relations);
+            }
         } catch (XMLStreamException ex) {
             //Logger.getLogger("global").log(Level.SEVERE, null, ex);
             throw new EJBException("ERROR occurred while parsing XML fragment  ("+xmlToParse.substring(0, 64)+"...); ", ex);
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java
index ecb1ae8f3df..b5a1f8a97c9 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java
@@ -10,6 +10,8 @@
 import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.api.dto.DatasetDTO;
 import edu.harvard.iq.dataverse.api.imports.ImportUtil.ImportType;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
@@ -91,6 +93,9 @@ public class ImportServiceBean {
     @EJB
     TemplateServiceBean templateService;
 
+    @EJB
+    DatasetRelationServiceBean datasetRelationService;
+
     /**
      * This is just a convenience method, for testing migration.  It creates 
      * a dummy dataverse with the directory name as dataverse name & alias.
@@ -302,7 +307,7 @@ public Dataset doImportHarvestedDataset(DataverseRequest dataverseRequest,
         try {
             Dataset harvestedDataset;
 
-            JsonParser parser = new JsonParser(datasetfieldService, metadataBlockService, settingsService, licenseService, datasetTypeService, harvestingClient, templateService);
+            JsonParser parser = new JsonParser(datasetfieldService, metadataBlockService, settingsService, licenseService, datasetTypeService, datasetRelationService, harvestingClient, templateService);
             parser.setLenient(true);
 
             if (existingDataset == null) {
@@ -336,7 +341,12 @@ public Dataset doImportHarvestedDataset(DataverseRequest dataverseRequest,
                 
                 // We will attempt to import the new version, and replace the 
                 // current, already existing version with it.                
-                harvestedVersion = parser.parseDatasetVersion(obj.getJsonObject("datasetVersion"));
+                JsonObject datasetVersionJson = obj.getJsonObject("datasetVersion");
+                harvestedVersion = parser.parseDatasetVersion(datasetVersionJson);
+                List<DatasetRelation> relations = parser.parseDatasetRelations(datasetVersionJson, harvestedVersion);
+                if (relations != null) {
+                    harvestedVersion.setRelations(relations);
+                }
                 
                 // For the purposes of validation, the version needs to be attached
                 // to a non-null dataset. We will create a throwaway temporary 
@@ -432,7 +442,7 @@ public JsonObjectBuilder doImport(DataverseRequest dataverseRequest, Dataverse o
         JsonObject obj = JsonUtil.getJsonObject(json);
         //and call parse Json to read it into a dataset   
         try {
-            JsonParser parser = new JsonParser(datasetfieldService, metadataBlockService, settingsService, licenseService, datasetTypeService, templateService);
+            JsonParser parser = new JsonParser(datasetfieldService, metadataBlockService, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
             parser.setLenient(!importType.equals(ImportType.NEW));
             Dataset ds = parser.parseDataset(obj, owner);
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/authorization/Permission.java b/src/main/java/edu/harvard/iq/dataverse/authorization/Permission.java
index 77ff12fdee7..a967c4a3015 100644
--- a/src/main/java/edu/harvard/iq/dataverse/authorization/Permission.java
+++ b/src/main/java/edu/harvard/iq/dataverse/authorization/Permission.java
@@ -53,7 +53,8 @@ public enum Permission implements java.io.Serializable {
     LinkDataset(BundleUtil.getStringFromBundle("permission.linkDataset"), true, Dataset.class, Dataverse.class),
     // Delete
     DeleteDataverse(BundleUtil.getStringFromBundle("permission.deleteDataverse"), true, Dataverse.class),
-    DeleteDatasetDraft(BundleUtil.getStringFromBundle("permission.deleteDataset"), true, Dataset.class);
+    DeleteDatasetDraft(BundleUtil.getStringFromBundle("permission.deleteDataset"), true, Dataset.class),
+    EditDatasetRelations(BundleUtil.getStringFromBundle("permission.editDatasetRelations"), true, Dataset.class);
 
 
     // FUTURE:
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelation.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelation.java
new file mode 100644
index 00000000000..3bdf8aaeff1
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelation.java
@@ -0,0 +1,144 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import java.io.Serializable;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import jakarta.persistence.*;
+
+/**
+ * Represents a relationship between datasets. This is an abstract class that defines basic properties and functionality
+ * for dataset relations, such as their originating dataset, relation type, and the version of the dataset definition
+ * point.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@Entity
+@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
+@DiscriminatorColumn(name = "relation_source", discriminatorType = DiscriminatorType.STRING)
+@Table(indexes = {
+        @Index(name="index_datasetrelation_dataset", columnList="dataset_id"),
+        @Index(name="index_datasetrelation_relateddataset", columnList="relateddataset_id"),
+        @Index(name="index_datasetrelation_definitionpoint", columnList="definitionpoint_id"),
+        @Index(name="index_datasetrelation_relateddataset_definitionpoint", columnList="relateddataset_id, definitionpoint_id")
+        },
+        uniqueConstraints = {
+                @UniqueConstraint(
+                        name = "datasetrelation_internal_unique",
+                        columnNames = {"dataset_id", "relateddataset_id", "relationtype_id", "definitionpoint_id"}
+                ),
+                @UniqueConstraint(
+                        name = "datasetrelation_external_unique",
+                        columnNames = {"dataset_id", "externalidentifier", "relationtype_id", "definitionpoint_id"}
+                )
+        }
+)
+@NamedQueries({
+        @NamedQuery(name = "DatasetRelation.getRelationById",
+                query="SELECT rel FROM DatasetRelation rel WHERE rel.id=:id"),
+        @NamedQuery(name = "DatasetRelation.deleteRelationById",
+                query="DELETE FROM DatasetRelation rel WHERE rel.id=:id"),
+        @NamedQuery(name = "DatasetRelation.removeRelationsByDatasetVersionId",
+                query = "DELETE FROM DatasetRelation rel WHERE rel.definitionPoint.id=:versionId"),
+        @NamedQuery(name = "DatasetRelation.getRelationsDefinedAtDatasetVersionId",
+                query="SELECT rel FROM DatasetRelation rel WHERE rel.definitionPoint.id=:versionId")
+})
+public abstract class DatasetRelation implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(nullable=false)
+    // The dataset from which this relation originates.
+    private Dataset dataset;
+
+    @ManyToOne
+    @JoinColumn(nullable=false)
+    private DatasetVersion definitionPoint;
+
+    @ManyToOne
+    @JoinColumn(nullable=false)
+    private DatasetRelationType relationType;
+
+    /**
+     * JPA no-args constructor. Client code should use the public constructor
+     * and not this one.
+     */
+    protected DatasetRelation(){}
+
+    protected DatasetRelation(Dataset dataset, DatasetRelationType relationType, DatasetVersion definitionPoint) {
+        this.dataset = dataset;
+        this.relationType = relationType;
+        this.definitionPoint = definitionPoint;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Dataset getDataset() {
+        return dataset;
+    }
+
+    public void setDataset(Dataset dataset) {
+        this.dataset = dataset;
+    }
+
+    public DatasetVersion getDefinitionPoint() {
+        return definitionPoint;
+    }
+
+    public void setDefinitionPoint(DatasetVersion definitionPoint) {
+        this.definitionPoint = definitionPoint;
+    }
+
+    public DatasetRelationType getRelationType() {
+        return relationType;
+    }
+
+    public void setRelationType(DatasetRelationType type) {
+        this.relationType = type;
+    }
+
+    @Override
+    public int hashCode() {
+        return (id != null ? id.hashCode() : 0);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if ( object == null ) return false;
+        if ( object == this ) return true;
+
+        if (!(object instanceof DatasetRelation)) {
+            return false;
+        }
+        DatasetRelation other = (DatasetRelation) object;
+
+        return (id==null && other.id==null) || (id!=null && id.equals(other.getId()));
+    }
+
+    @Override
+    public String toString() {
+        return "edu.harvard.iq.dataverse.datasetrelation.DatasetRelation[ id=" + id + " ]";
+    }
+
+    public abstract String toKey();
+
+    /**
+     * Returns a key for comparing the same relation across different dataset
+     * versions. Unlike {@link #toKey()}, it does not include the definition point.
+     */
+    public abstract String toVersionComparisonKey();
+
+    public abstract DatasetRelation copy(DatasetVersion newDefinitionPoint);
+
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationAlgorithm.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationAlgorithm.java
new file mode 100644
index 00000000000..33fe1ed3e0c
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationAlgorithm.java
@@ -0,0 +1,51 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import java.util.List;
+
+/**
+ * Interface for algorithms that calculate or retrieve relations for a dataset.
+ * This allows swapping the implementation (e.g. from simple direct relation-based to complex graph-based clustering).
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+public interface DatasetRelationAlgorithm {
+    
+    /**
+     * Retrieves relations for a given dataset.
+     * 
+     * @param dataset The dataset for which to find relations.
+     * @param version Optional dataset version for version-specific filtering.
+     * @param relationTypeNames Optional filter by relation type names.
+     * @param datasetTypeNames Optional filter by dataset type names of the related dataset.
+     * @param relationSources Optional filter by relation source (internal, external).
+     * @param limit Maximum number of results.
+     * @param offset Offset for pagination.
+     * @return A list of DatasetRelation objects.
+     */
+    List<DatasetRelation> getRelations(Dataset dataset, DatasetVersion version, List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources, Integer limit, Integer offset);
+
+    /**
+     * Retrieves relation facet counts using the same normalized relation set as listing.
+     *
+     * @param groupBy The field to group by ("relationType" or "datasetType").
+     * @param relationTypeNames Optional filter by relation type names.
+     * @param datasetTypeNames Optional filter by dataset type names of the related dataset.
+     * @param relationSources Optional filter by relation source (internal, external).
+     */
+    List<Object[]> getRelationFacetCounts(Dataset dataset, DatasetVersion version, String groupBy,
+            List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources);
+
+    /**
+     * Retrieves the total number of relations returned for a dataset.
+     * 
+     * @param dataset The dataset.
+     * @param version Optional dataset version for version-specific filtering.
+     * @param relationTypeNames Optional filter by relation type names.
+     * @param datasetTypeNames Optional filter by dataset type names of the related dataset.
+     * @param relationSources Optional filter by relation source (internal, external).
+     * @return Total number of relations returned by {@link #getRelations} with the same filters.
+     */
+    Long getTotalDatasetRelationCountFor(Dataset dataset, DatasetVersion version, List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources);
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexing.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexing.java
new file mode 100644
index 00000000000..b30a2f6c1af
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexing.java
@@ -0,0 +1,71 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Utility class for scheduling indexing tasks related to datasets and their relations.
+ * The methods in this class are designed to handle the indexing of datasets whenever their relationships change and an
+ * index update is necessary, i.e., to update the relatedDatasetCount.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+public final class DatasetRelationIndexing {
+
+    private DatasetRelationIndexing() {
+    }
+
+    public static void schedule(CommandContext ctxt, Dataset definingDataset, Collection<DatasetRelation> relations) {
+        Map<Long, Dataset> datasets = relatedDatasets(relations);
+        datasets.put(definingDataset.getId(), definingDataset);
+        ctxt.index().asyncIndexDatasetList(datasets.values().stream().toList(), true);
+    }
+
+    public static void scheduleChanges(CommandContext ctxt, Dataset definingDataset,
+            Collection<DatasetRelation> previousRelations, Collection<DatasetRelation> currentRelations) {
+        Map<Long, Dataset> previousRelatedDatasets = relatedDatasets(previousRelations);
+        Map<Long, Dataset> currentRelatedDatasets = relatedDatasets(currentRelations);
+        Map<Long, Long> previousRelationCounts = relatedDatasetCounts(previousRelations);
+        Map<Long, Long> currentRelationCounts = relatedDatasetCounts(currentRelations);
+
+        Map<Long, Dataset> changedRelatedDatasets = new LinkedHashMap<>();
+        previousRelatedDatasets.forEach((id, dataset) -> {
+            if (!Objects.equals(previousRelationCounts.get(id), currentRelationCounts.get(id))) {
+                changedRelatedDatasets.put(id, dataset);
+            }
+        });
+        currentRelatedDatasets.forEach((id, dataset) -> {
+            if (!Objects.equals(previousRelationCounts.get(id), currentRelationCounts.get(id))) {
+                changedRelatedDatasets.put(id, dataset);
+            }
+        });
+        changedRelatedDatasets.put(definingDataset.getId(), definingDataset);
+        ctxt.index().asyncIndexDatasetList(changedRelatedDatasets.values().stream().toList(), true);
+    }
+
+    private static Map<Long, Dataset> relatedDatasets(Collection<DatasetRelation> relations) {
+        Map<Long, Dataset> datasets = new LinkedHashMap<>();
+        for (DatasetRelation relation : relations) {
+            if (relation instanceof InternalDatasetRelation internalRelation) {
+                Dataset relatedDataset = internalRelation.getRelatedDataset();
+                datasets.put(relatedDataset.getId(), relatedDataset);
+            }
+        }
+        return datasets;
+    }
+
+    private static Map<Long, Long> relatedDatasetCounts(Collection<DatasetRelation> relations) {
+        Map<Long, Long> counts = new LinkedHashMap<>();
+        for (DatasetRelation relation : relations) {
+            if (relation instanceof InternalDatasetRelation internalRelation) {
+                counts.merge(internalRelation.getRelatedDataset().getId(), 1L, Long::sum);
+            }
+        }
+        return counts;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationServiceBean.java
new file mode 100644
index 00000000000..e08239e0bd9
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationServiceBean.java
@@ -0,0 +1,227 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetServiceBean;
+import edu.harvard.iq.dataverse.DatasetVersion;
+
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
+import jakarta.ejb.EJB;
+import jakarta.ejb.Stateless;
+import jakarta.ejb.TransactionAttribute;
+import jakarta.ejb.TransactionAttributeType;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.NoResultException;
+import jakarta.persistence.PersistenceContext;
+
+/**
+ * Service bean for managing dataset relations.
+ * It uses an injected DatasetRelationAlgorithm to compute and filter dataset relations.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@Stateless
+@Named
+public class DatasetRelationServiceBean {
+
+    private static final Logger logger = Logger.getLogger(DatasetRelationServiceBean.class.getCanonicalName());
+
+    @PersistenceContext
+    private EntityManager em;
+
+    @EJB
+    private DatasetRelationTypeServiceBean relationTypeService;
+
+    @EJB
+    private DatasetServiceBean datasetService;
+
+    @Inject
+    private DatasetRelationAlgorithm algorithm;
+
+    public void deleteAllDatasetRelationsFor(DatasetVersion v) {
+        em.createNamedQuery("DatasetRelation.removeRelationsByDatasetVersionId")
+                .setParameter("versionId", v.getId())
+                .executeUpdate();
+    }
+
+    public void deleteAllDatasetRelationsInvolving(Dataset dataset) {
+        em.createQuery("DELETE FROM InternalDatasetRelation rel WHERE rel.relatedDataset = :dataset")
+                .setParameter("dataset", dataset)
+                .executeUpdate();
+        em.createQuery("DELETE FROM DatasetRelation rel WHERE rel.dataset = :dataset")
+                .setParameter("dataset", dataset)
+                .executeUpdate();
+    }
+
+    public DatasetRelation getDatasetRelationById(Long id) {
+        try {
+            return em.createNamedQuery("DatasetRelation.getRelationById", DatasetRelation.class)
+                    .setParameter("id", id)
+                    .getSingleResult();
+        } catch (NoResultException e) {
+            return null;
+        }
+    }
+
+    public List<DatasetRelation> getDatasetRelationsDefinedAt(DatasetVersion version) {
+        return em.createNamedQuery("DatasetRelation.getRelationsDefinedAtDatasetVersionId", DatasetRelation.class)
+                .setParameter("versionId", version.getId())
+                .getResultList();
+    }
+
+    public void deleteDatasetRelationById(Long id) {
+        em.createNamedQuery("DatasetRelation.deleteRelationById")
+          .setParameter("id", id)
+          .executeUpdate();
+    }
+
+    public List<DatasetRelation> getDatasetRelationsFor(Dataset d, DatasetVersion v, List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources, Integer limit, Integer offset) {
+        return algorithm.getRelations(d, v, relationTypeNames, datasetTypeNames, relationSources, limit, offset);
+    }
+
+    public List<Object[]> getDatasetRelationFacetCountsFor(Dataset d, DatasetVersion v, String groupBy,
+            List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources) {
+        return algorithm.getRelationFacetCounts(d, v, groupBy, relationTypeNames, datasetTypeNames, relationSources);
+    }
+
+    public Long getTotalDatasetRelationCountFor(Dataset d, DatasetVersion v) {
+        return algorithm.getTotalDatasetRelationCountFor(d, v, null, null, null);
+    }
+
+    public Long getTotalDatasetRelationCountFor(Dataset d, DatasetVersion v, List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources) {
+        return algorithm.getTotalDatasetRelationCountFor(d, v, relationTypeNames, datasetTypeNames, relationSources);
+    }
+
+    public DatasetRelation addDatasetRelation(DatasetRelation relation) {
+        em.persist(relation);
+        em.flush();
+        return relation;
+    }
+
+    /**
+     * A relation is a duplicate when it has the same endpoints, definition
+     * point, and relation type as an existing relation.
+     */
+    public boolean isDuplicate(DatasetRelation relation) {
+        if (relation instanceof InternalDatasetRelation internalRelation) {
+            var query = em.createQuery("SELECT COUNT(rel) FROM InternalDatasetRelation rel "
+                    + "WHERE rel.dataset = :dataset AND rel.relatedDataset = :relatedDataset "
+                    + "AND rel.definitionPoint = :definitionPoint AND rel.relationType.id = :relationTypeId", Long.class)
+                    .setParameter("dataset", relation.getDataset())
+                    .setParameter("relatedDataset", internalRelation.getRelatedDataset())
+                    .setParameter("definitionPoint", relation.getDefinitionPoint())
+                    .setParameter("relationTypeId", relation.getRelationType().getId());
+            return query.getSingleResult() > 0;
+        } else if (relation instanceof ExternalDatasetRelation externalRelation) {
+            var query = em.createQuery("SELECT COUNT(rel) FROM ExternalDatasetRelation rel "
+                    + "WHERE rel.dataset = :dataset AND rel.externalIdentifier = :externalIdentifier "
+                    + "AND rel.definitionPoint = :definitionPoint AND rel.relationType.id = :relationTypeId", Long.class)
+                    .setParameter("dataset", relation.getDataset())
+                    .setParameter("externalIdentifier", externalRelation.getExternalIdentifier())
+                    .setParameter("definitionPoint", relation.getDefinitionPoint())
+                    .setParameter("relationTypeId", relation.getRelationType().getId());
+            return query.getSingleResult() > 0;
+        }
+        throw new IllegalArgumentException("Unknown dataset relation type");
+    }
+
+    public boolean containsDuplicates(List<DatasetRelation> relations) {
+        for (int i = 0; i < relations.size(); i++) {
+            for (int j = i + 1; j < relations.size(); j++) {
+                if (areDuplicates(relations.get(i), relations.get(j))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean areDuplicates(DatasetRelation first, DatasetRelation second) {
+        if (!first.getDataset().equals(second.getDataset())
+                || !first.getDefinitionPoint().equals(second.getDefinitionPoint())
+                || !first.getRelationType().equals(second.getRelationType())) {
+            return false;
+        }
+        if (first instanceof InternalDatasetRelation firstInternal
+                && second instanceof InternalDatasetRelation secondInternal) {
+            return firstInternal.getRelatedDataset().equals(secondInternal.getRelatedDataset());
+        }
+        if (first instanceof ExternalDatasetRelation firstExternal
+                && second instanceof ExternalDatasetRelation secondExternal) {
+            return firstExternal.getExternalIdentifier().equals(secondExternal.getExternalIdentifier());
+        }
+        return false;
+    }
+
+    public List<DatasetRelation> replaceAllDatasetRelationsFor(DatasetVersion v, List<DatasetRelation> newRelations) {
+        List<DatasetRelation> existingRelations = getDatasetRelationsDefinedAt(v);
+
+        Set<String> existingKeys = existingRelations.stream()
+                .map(DatasetRelation::toKey)
+                .collect(Collectors.toSet());
+        Set<String> newKeys = newRelations.stream()
+                .map(DatasetRelation::toKey)
+                .collect(Collectors.toSet());
+
+        List<DatasetRelation> toAdd = newRelations.stream()
+                .filter(r -> !existingKeys.contains(r.toKey()))
+                .toList();
+        List<DatasetRelation> toRemove = existingRelations.stream()
+                .filter(r -> !newKeys.contains(r.toKey()))
+                .toList();
+
+        if (!toRemove.isEmpty()) {
+            List<Long> toRemoveIds = toRemove.stream().map(DatasetRelation::getId).toList();
+            em.createQuery("DELETE FROM DatasetRelation dr WHERE dr.id IN :toRemoveIds")
+                    .setParameter("toRemoveIds", toRemoveIds)
+                    .executeUpdate();
+        }
+        for (DatasetRelation r : toAdd) {
+            em.persist(r);
+        }
+
+        em.flush();
+
+        // Re-fetch to ensure IDs are populated
+        return getDatasetRelationsDefinedAt(v);
+    }
+
+    public DatasetRelation fromDTO(DatasetRelationDTO dto, DatasetVersion version) {
+        Dataset d = version.getDataset();
+        DatasetRelationType type;
+        if (dto.getRelationTypeName() != null) {
+            type = relationTypeService.findByName(dto.getRelationTypeName());
+            if (type == null) {
+                logger.severe("Failed to find dataset relation type with name " + dto.getRelationTypeName());
+                return null;
+            }
+        } else {
+            type = relationTypeService.getDefault();
+            if (type == null) {
+                logger.severe("Failed to find a default dataset relation type");
+                return null;
+            }
+        }
+
+        if (dto.getRelatedDatasetPid() != null) {
+            Dataset relatedDataset = datasetService.findByGlobalId(dto.getRelatedDatasetPid());
+            if (relatedDataset == null) {
+                logger.severe("Failed to find related dataset with PID " + dto.getRelatedDatasetPid());
+                return null;
+            }
+            return new InternalDatasetRelation(d, relatedDataset, type, version);
+        } else if (dto.getExternalIdentifier() != null) {
+            return new ExternalDatasetRelation(d, dto.getExternalIdentifier(), dto.getIdentifierScheme(), dto.getDatasetType(), type, version);
+        } else {
+            logger.severe("Relation DTO must have either relatedDatasetPid or externalIdentifier");
+            return null;
+        }
+    }
+
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationType.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationType.java
new file mode 100644
index 00000000000..381a0cbe267
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationType.java
@@ -0,0 +1,147 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import jakarta.persistence.*;
+
+import java.io.Serializable;
+
+/**
+ * Represents a type of relationship between datasets within the system.
+ * Provides attributes for naming the relationship, describing its purpose, and identifying if it is the default type
+ * of relation.
+ * Additionally, supports the concept of an inverse relationship types.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@Entity
+@NamedQueries({
+        @NamedQuery(name = "DatasetRelationType.findAll",
+                query = "SELECT drt FROM DatasetRelationType drt"),
+        @NamedQuery(name = "DatasetRelationType.getById",
+                query="SELECT drt FROM DatasetRelationType drt WHERE drt.id=:id"),
+        @NamedQuery(name = "DatasetRelationType.getByName",
+                query="SELECT drt FROM DatasetRelationType drt WHERE drt.name=:name"),
+        @NamedQuery(name = "DatasetRelationType.getDefault",
+                query="SELECT drt FROM DatasetRelationType drt WHERE drt.isDefault=true"),
+        @NamedQuery(name = "DatasetRelationType.deleteById",
+                query = "DELETE FROM DatasetRelationType drt WHERE drt.id=:id"),
+})
+public class DatasetRelationType implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable=false, unique=true)
+    private String name;
+
+    @Column(nullable=false, unique=true)
+    private String displayName;
+
+    @Column
+    private String description;
+
+    @Column(nullable = false)
+    private boolean isDefault;
+
+    @OneToOne(cascade = {CascadeType.PERSIST})
+    @JoinColumn(unique=true)
+    private DatasetRelationType inverse;
+
+
+    /**
+     * Constructing a relation type with an inverse relation type.
+     * @param name The name of the relation type.
+     * @param displayName The display name of the relation type.
+     * @param description The description of the relation type.
+     * @param inverse The inverse relation type.
+     */
+    public DatasetRelationType(String name, String displayName, String description, DatasetRelationType inverse) {
+        this.name = name;
+        this.displayName = displayName;
+        this.description = description;
+        this.inverse = inverse;
+        if (inverse.getInverse() != this) {
+            inverse.setInverse(this);
+        }
+    }
+
+    /**
+     * Constructing a relation type.
+     * @param name The name of the relation type.
+     * @param displayName The display name of the relation type.
+     * @param description The description of the relation type.
+     */
+    public DatasetRelationType(String name, String displayName, String description) {
+        this.name = name;
+        this.displayName = displayName;
+        this.description = description;
+    }
+
+    /**
+     * Constructing a relation type.
+     * @param name The name of the relation type.
+     * @param displayName The display name of the relation type.
+     */
+    public DatasetRelationType(String name, String displayName) {
+        this.name = name;
+        this.displayName = displayName;
+    }
+
+    /**
+     * JPA no-args constructor. Client code should use the public constructor
+     * and not this one.
+     */
+    protected DatasetRelationType(){}
+
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public DatasetRelationType getInverse() {
+        return inverse;
+    }
+
+    public void setInverse(DatasetRelationType inverse) {
+        this.inverse = inverse;
+        if (inverse != null && inverse.getInverse() != this) {
+            inverse.setInverse(this);
+        }
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public void setDisplayName(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public boolean isDefault() {
+        return isDefault;
+    }
+
+    public void setDefault(boolean aDefault) {
+        isDefault = aDefault;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeException.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeException.java
new file mode 100644
index 00000000000..4f70f06b6f8
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeException.java
@@ -0,0 +1,16 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import jakarta.ejb.ApplicationException;
+
+/**
+ * A validation failure while changing a relation type.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@ApplicationException(rollback = false)
+public class DatasetRelationTypeException extends RuntimeException {
+
+    public DatasetRelationTypeException(String message) {
+        super(message);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeServiceBean.java
new file mode 100644
index 00000000000..6775d45757e
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationTypeServiceBean.java
@@ -0,0 +1,155 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.api.AbstractApiBean.WrappedResponse;
+import edu.harvard.iq.dataverse.api.ApiConstants;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import edu.harvard.iq.dataverse.util.json.NullSafeJsonBuilder;
+import jakarta.ejb.Stateless;
+import jakarta.inject.Named;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.NoResultException;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceException;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import org.eclipse.persistence.exceptions.DatabaseException;
+
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Service bean for managing dataset relation types.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@Stateless
+@Named
+public class DatasetRelationTypeServiceBean {
+
+    private static final Logger logger = Logger.getLogger(DatasetRelationTypeServiceBean.class.getName());
+
+    @PersistenceContext
+    EntityManager em;
+
+    public List<DatasetRelationType> listAll() {
+        return em.createNamedQuery("DatasetRelationType.findAll", DatasetRelationType.class).getResultList();
+    }
+
+    public DatasetRelationType findById(long id) {
+        try {
+            return em.createNamedQuery("DatasetRelationType.getById", DatasetRelationType.class)
+                    .setParameter("id", id)
+                    .getSingleResult();
+        } catch (NoResultException e) {
+            logger.log(Level.WARNING, "Couldn't find a dataset relation type with id " + id);
+            return null;
+        }
+    }
+
+    public DatasetRelationType findByName(String name) {
+        if (name == null) {
+            return null;
+        }
+
+        try {
+            return em.createNamedQuery("DatasetRelationType.getByName", DatasetRelationType.class)
+                    .setParameter("name", name)
+                    .getSingleResult();
+        } catch (NoResultException e) {
+            logger.log(Level.WARNING, "Couldn't find a dataset relation type with name " + name);
+            return null;
+        }
+    }
+
+    public DatasetRelationType getDefault() {
+        try {
+            return em.createNamedQuery("DatasetRelationType.getDefault", DatasetRelationType.class)
+                    .getSingleResult();
+        } catch (NoResultException e) {
+            return null;
+        }
+    }
+
+    public DatasetRelationType save(DatasetRelationType relationType) throws DatasetRelationTypeException {
+        validate(relationType);
+        relationType.setDefault(getDefault() == null);
+        em.persist(relationType);
+        em.flush();
+        return relationType;
+    }
+
+    public void delete(DatasetRelationType doomed) throws DatasetRelationTypeException {
+        if (doomed.isDefault()) {
+            throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.delete.default"));
+        }
+        DatasetRelationType inverse = doomed.getInverse();
+
+        if (isInUse(doomed) || (inverse != null && isInUse(inverse))) {
+            throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.delete.referenced"));
+        }
+
+        if (inverse != null) {
+            inverse.setInverse(null);
+            doomed.setInverse(null);
+            em.merge(inverse);
+            em.merge(doomed);
+        }
+        em.remove(em.merge(doomed));
+        em.flush();
+    }
+
+    public void setDefault(DatasetRelationType relationType) {
+        DatasetRelationType prevDefault = getDefault();
+        if (prevDefault != null) {
+            prevDefault.setDefault(false);
+            em.merge(prevDefault);
+        }
+        relationType.setDefault(true);
+        em.merge(relationType);
+        em.flush();
+    }
+
+    private void validate(DatasetRelationType relationType) {
+        if (isBlank(relationType.getName()) || isBlank(relationType.getDisplayName())) {
+            throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create.notNull"));
+        }
+        if (exists(relationType.getName(), relationType.getDisplayName())) {
+            throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create.duplicate"));
+        }
+        DatasetRelationType inverse = relationType.getInverse();
+        if (inverse != null && inverse != relationType) {
+            if (isBlank(inverse.getName()) || isBlank(inverse.getDisplayName())) {
+                throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create.notNull"));
+            }
+            if (inverse.getName().equals(relationType.getName()) || inverse.getDisplayName().equals(relationType.getDisplayName())) {
+                throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create.duplicate"));
+            }
+            if (exists(inverse.getName(), inverse.getDisplayName())) {
+                throw new DatasetRelationTypeException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create.duplicate"));
+            }
+        }
+    }
+
+    private boolean exists(String name, String displayName) {
+        return em.createQuery("SELECT COUNT(drt) FROM DatasetRelationType drt "
+                        + "WHERE drt.name = :name OR drt.displayName = :displayName", Long.class)
+                .setParameter("name", name)
+                .setParameter("displayName", displayName)
+                .getSingleResult() > 0;
+    }
+
+    private boolean isBlank(String value) {
+        return value == null || value.isBlank();
+    }
+
+    private boolean isInUse(DatasetRelationType drt) {
+        return em.createQuery(
+                        "SELECT COUNT(relation) FROM DatasetRelation relation WHERE relation.relationType = :relationType",
+                        Long.class)
+                .setParameter("relationType", drt)
+                .getSingleResult() > 0;
+    }
+
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/ExternalDatasetRelation.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/ExternalDatasetRelation.java
new file mode 100644
index 00000000000..5fa24178b1b
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/ExternalDatasetRelation.java
@@ -0,0 +1,77 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import jakarta.persistence.Column;
+import jakarta.persistence.DiscriminatorValue;
+import jakarta.persistence.Entity;
+
+/**
+ * Represents a relationship between a dataset and an external dataset. This class is used to describe and manage links
+ * to datasets that exist outside the current Dataverse instance.
+ *
+ * This class extends {@link DatasetRelation} and specializes the relationship to describe external datasets by
+ * providing additional fields for external-specific details like external identifier, identifier scheme, and dataset
+ * type.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@Entity
+@DiscriminatorValue("external")
+public class ExternalDatasetRelation extends DatasetRelation {
+
+    @Column(length = 512)
+    private String externalIdentifier;
+    private String identifierScheme;
+    private String datasetType;
+
+    public ExternalDatasetRelation(Dataset dataset, String externalIdentifier, String identifierScheme, String datasetType, DatasetRelationType relationType, DatasetVersion definitionPoint) {
+        super(dataset, relationType, definitionPoint);
+        this.externalIdentifier = externalIdentifier;
+        this.identifierScheme = identifierScheme;
+        this.datasetType = datasetType;
+    }
+
+    protected ExternalDatasetRelation() {
+        super();
+    }
+
+    public String getExternalIdentifier() {
+        return externalIdentifier;
+    }
+
+    public void setExternalIdentifier(String externalIdentifier) {
+        this.externalIdentifier = externalIdentifier;
+    }
+
+    public String getIdentifierScheme() {
+        return identifierScheme;
+    }
+
+    public void setIdentifierScheme(String identifierScheme) {
+        this.identifierScheme = identifierScheme;
+    }
+
+    public String getDatasetType() {
+        return datasetType;
+    }
+
+    public void setDatasetType(String datasetType) {
+        this.datasetType = datasetType;
+    }
+
+    @Override
+    public String toKey() {
+        return toVersionComparisonKey() + "|" + getDefinitionPoint().getId();
+    }
+
+    @Override
+    public String toVersionComparisonKey() {
+        return getDataset().getId() + "|" + externalIdentifier + "|" + (identifierScheme != null ? identifierScheme : "") + "|" + (datasetType != null ? datasetType : "") + "|" + (getRelationType() != null ? getRelationType().getId() : "");
+    }
+
+    @Override
+    public DatasetRelation copy(DatasetVersion newDefinitionPoint) {
+        return new ExternalDatasetRelation(getDataset(), externalIdentifier, identifierScheme, datasetType, getRelationType(), newDefinitionPoint);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/InternalDatasetRelation.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/InternalDatasetRelation.java
new file mode 100644
index 00000000000..239f1f17d92
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/InternalDatasetRelation.java
@@ -0,0 +1,67 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import jakarta.persistence.DiscriminatorValue;
+import jakarta.persistence.Entity;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+
+/**
+ * Represents a relationship between two datasets that exist within the current Dataverse instance
+ *
+ * This class extends {@code DatasetRelation} to provide functionality specific to internal relationships. An internal
+ * dataset relation is characterized by its source dataset, related dataset, relation type, and the dataset version
+ * that is the definition point of the relation.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@Entity
+@DiscriminatorValue("internal")
+public class InternalDatasetRelation extends DatasetRelation {
+
+    @ManyToOne
+    @JoinColumn(name = "relateddataset_id")
+    private Dataset relatedDataset;
+
+    public InternalDatasetRelation(Dataset datasetA, Dataset datasetB, DatasetRelationType relationType, DatasetVersion definitionPoint) {
+        if (datasetA == null || datasetB == null || definitionPoint == null) {
+            throw new IllegalArgumentException("Cannot create a relation for a null dataset or definition point");
+        }
+        if (!datasetA.equals(definitionPoint.getDataset())) {
+            throw new IllegalArgumentException("The definition point must belong to the relation source dataset");
+        }
+
+        setDataset(datasetA);
+        setRelatedDataset(datasetB);
+        setRelationType(relationType);
+        setDefinitionPoint(definitionPoint);
+    }
+
+    protected InternalDatasetRelation() {
+        super();
+    }
+
+    public Dataset getRelatedDataset() {
+        return relatedDataset;
+    }
+
+    public void setRelatedDataset(Dataset relatedDataset) {
+        this.relatedDataset = relatedDataset;
+    }
+
+    @Override
+    public String toKey() {
+        return toVersionComparisonKey() + "|" + getDefinitionPoint().getId();
+    }
+
+    @Override
+    public String toVersionComparisonKey() {
+        return getDataset().getId() + "|" + relatedDataset.getId() + "|" + (getRelationType() != null ? getRelationType().getId() : "");
+    }
+
+    @Override
+    public DatasetRelation copy(DatasetVersion newDefinitionPoint) {
+        return new InternalDatasetRelation(getDataset(), relatedDataset, getRelationType(), newDefinitionPoint);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/datasetrelation/SqlDirectDatasetRelationAlgorithm.java b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/SqlDirectDatasetRelationAlgorithm.java
new file mode 100644
index 00000000000..93fa8f35daa
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/datasetrelation/SqlDirectDatasetRelationAlgorithm.java
@@ -0,0 +1,380 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.Query;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Default implementation of DatasetRelationAlgorithm using JPA and SQL queries.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@ApplicationScoped
+public class SqlDirectDatasetRelationAlgorithm implements DatasetRelationAlgorithm {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    private static final String WITH_LATEST_RELEASED_VERSIONS =
+            " WITH latest_released_versions AS MATERIALIZED ( " +
+            "     SELECT DISTINCT ON (dataset_id) id, dataset_id " +
+            "     FROM datasetversion " +
+            "     WHERE versionstate = 'RELEASED' " +
+            "     ORDER BY dataset_id, id DESC " +
+            " ), ";
+
+    private static final String WITH_CANDIDATE_RELATIONS =
+            " candidate_relations AS ( " +
+            // Relations defined on the requested version.
+            "     SELECT dr.id, 0 AS definition_point_priority " +
+            "     FROM datasetrelation dr " +
+            "     WHERE dr.definitionpoint_id = ? " +
+            "     UNION ALL " +
+            // Incoming relations defined on the latest released version of another dataset.
+            "     SELECT dr.id, 1 AS definition_point_priority " +
+            "     FROM datasetrelation dr " +
+            "     JOIN latest_released_versions lrv ON dr.definitionpoint_id = lrv.id " +
+            "     WHERE lrv.dataset_id != ? " +
+            "       AND dr.relateddataset_id = ? " +
+            " ) ";
+
+    // Normalize and deduplicate relation types from the requested dataset's perspective.
+    private static final String WITH_DEDUPLICATED_RELATIONS =
+            " , normalized_candidate_relations AS ( " +
+            "     SELECT cr.id, cr.definition_point_priority, dr.relation_source AS normalized_relation_source, " +
+            "         CASE " +
+            "             WHEN dr.dataset_id = ? THEN dr.relationtype_id " +
+            "             ELSE rt.inverse_id " +
+            "         END AS normalized_relation_type_id, " +
+            "         CASE WHEN dr.relation_source = 'internal' " +
+            "             THEN CASE WHEN dr.dataset_id = ? THEN CAST(dr.relateddataset_id AS VARCHAR) ELSE CAST(dr.dataset_id AS VARCHAR) END " +
+            "             ELSE dr.externalidentifier " +
+            "         END AS normalized_related_dataset " +
+            "     FROM candidate_relations cr " +
+            "     JOIN datasetrelation dr ON cr.id = dr.id " +
+            "     LEFT JOIN datasetrelationtype rt ON dr.relationtype_id = rt.id " +
+            " ), " +
+            " deduplicated_relations AS ( " +
+            "     SELECT DISTINCT ON (normalized_relation_source, normalized_relation_type_id, normalized_related_dataset) " +
+            "         id, definition_point_priority " +
+            "     FROM normalized_candidate_relations " +
+            "     ORDER BY normalized_relation_source, normalized_relation_type_id, normalized_related_dataset, definition_point_priority, id " +
+            " ) ";
+
+    private static final String GET_TOTAL_RELATION_COUNT_QUERY_BASE =
+            " SELECT COUNT(*) " +
+            " FROM deduplicated_relations ddr " +
+            " JOIN datasetrelation dr ON ddr.id = dr.id ";
+
+    private static final String GET_RELATIONS_QUERY_BASE =
+            " SELECT dr.* " +
+            " FROM deduplicated_relations ddr " +
+            " JOIN datasetrelation dr ON ddr.id = dr.id ";
+
+    private static final String JOIN_RELATION_TYPES = 
+            // Get information about dataset relation types
+            " JOIN datasetrelationtype rt ON dr.relationtype_id = rt.id " +
+            " LEFT JOIN datasetrelationtype inv ON rt.inverse_id = inv.id ";
+
+    private static final String WHERE_RELATION_TYPE_MATCHES = 
+            // The relation type must match the given one (inverted if necessary)
+            " ( " +
+            "    (dr.dataset_id = ? AND rt.name IN (?)) " +
+            "    OR " +
+            "    (dr.relateddataset_id = ? AND inv.name IN (?)) " +
+            " ) ";
+
+    private static final String JOIN_DATASET_TYPES = 
+            " LEFT JOIN dataset d_related ON dr.relation_source = 'internal' " +
+            "     AND (CASE WHEN dr.dataset_id = ? THEN dr.relateddataset_id ELSE dr.dataset_id END) = d_related.id " +
+            " LEFT JOIN datasettype dt ON d_related.datasettype_id = dt.id " +
+            "     OR (dr.relation_source = 'external' AND dt.displayname = dr.datasettype " +
+            "         AND NOT EXISTS (SELECT 1 FROM datasettype duplicate_dt " +
+            "                         WHERE duplicate_dt.displayname = dt.displayname AND duplicate_dt.id <> dt.id)) ";
+
+    private static final String WHERE_DATASET_TYPE_MATCHES = 
+            " ((dr.relation_source = 'internal' AND dt.name IN (?)) " +
+            " OR (dr.relation_source = 'external' AND (dr.datasettype IN (?) OR dt.name IN (?)))) ";
+
+    private static final String WHERE_RELATION_SOURCE_MATCHES =
+            " (dr.relation_source IN (?)) ";
+
+    private static final String ORDER_BY_REQUESTED_DATASET_FIRST =
+            " ORDER BY ddr.definition_point_priority ASC, dr.id ASC ";
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public List<DatasetRelation> getRelations(Dataset d, DatasetVersion v, List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources, Integer limit, Integer offset) {
+        StringBuilder sql = new StringBuilder();
+
+        sql.append(WITH_LATEST_RELEASED_VERSIONS)
+                .append(WITH_CANDIDATE_RELATIONS)
+                .append(WITH_DEDUPLICATED_RELATIONS)
+                .append(GET_RELATIONS_QUERY_BASE);
+
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            sql.append(JOIN_RELATION_TYPES);
+        }
+        
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            sql.append(JOIN_DATASET_TYPES);
+        }
+
+        sql.append(" WHERE 1 = 1 ");
+
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            sql.append(" AND ").append(WHERE_RELATION_TYPE_MATCHES.replace("(?)", 
+                    "(" + relationTypeNames.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+        
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            sql.append(" AND ").append(WHERE_DATASET_TYPE_MATCHES.replace("(?)", 
+                    "(" + datasetTypeNames.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+
+        if (relationSources != null && !relationSources.isEmpty()) {
+            sql.append(" AND ").append(WHERE_RELATION_SOURCE_MATCHES.replace("(?)", 
+                    "(" + relationSources.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+
+        sql.append(ORDER_BY_REQUESTED_DATASET_FIRST);
+
+        Query query = em.createNativeQuery(sql.toString(), DatasetRelation.class);
+        int i = 1;
+
+        // WITH_CANDIDATE_RELATIONS
+        query.setParameter(i++, v.getId());
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+
+        // WITH_DEDUPLICATED_RELATIONS
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            // JOIN_DATASET_TYPES
+            query.setParameter(i++, d.getId());
+        }
+
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            // WHERE_RELATION_TYPE_MATCHES
+            query.setParameter(i++, d.getId());
+            for (String typeName : relationTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            query.setParameter(i++, d.getId());
+            for (String typeName : relationTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+        }
+        
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            // WHERE_DATASET_TYPE_MATCHES
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+        }
+
+        if (relationSources != null && !relationSources.isEmpty()) {
+            // WHERE_RELATION_SOURCE_MATCHES
+            for (String source : relationSources) {
+                query.setParameter(i++, source);
+            }
+        }
+
+        return (List<DatasetRelation>) query.setMaxResults(limit)
+                .setFirstResult(offset)
+                .getResultList();
+    }
+
+    @Override
+    public Long getTotalDatasetRelationCountFor(Dataset d, DatasetVersion v, List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources) {
+        StringBuilder sql = new StringBuilder();
+
+        sql.append(WITH_LATEST_RELEASED_VERSIONS)
+                .append(WITH_CANDIDATE_RELATIONS)
+                .append(WITH_DEDUPLICATED_RELATIONS)
+                .append(GET_TOTAL_RELATION_COUNT_QUERY_BASE);
+
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            sql.append(JOIN_RELATION_TYPES);
+        }
+        
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            sql.append(JOIN_DATASET_TYPES);
+        }
+
+        sql.append(" WHERE 1 = 1 ");
+
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            sql.append(" AND ").append(WHERE_RELATION_TYPE_MATCHES.replace("(?)", 
+                    "(" + relationTypeNames.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+        
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            sql.append(" AND ").append(WHERE_DATASET_TYPE_MATCHES.replace("(?)", 
+                    "(" + datasetTypeNames.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+
+        if (relationSources != null && !relationSources.isEmpty()) {
+            sql.append(" AND ").append(WHERE_RELATION_SOURCE_MATCHES.replace("(?)", 
+                    "(" + relationSources.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+
+        Query query = em.createNativeQuery(sql.toString());
+        int i = 1;
+
+        // WITH_CANDIDATE_RELATIONS
+        query.setParameter(i++, v.getId());
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+
+        // WITH_DEDUPLICATED_RELATIONS
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            // JOIN_DATASET_TYPES
+            query.setParameter(i++, d.getId());
+        }
+
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            // WHERE_RELATION_TYPE_MATCHES
+            query.setParameter(i++, d.getId());
+            for (String typeName : relationTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            query.setParameter(i++, d.getId());
+            for (String typeName : relationTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+        }
+        
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            // WHERE_DATASET_TYPE_MATCHES
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+        }
+
+        if (relationSources != null && !relationSources.isEmpty()) {
+            // WHERE_RELATION_SOURCE_MATCHES
+            for (String source : relationSources) {
+                query.setParameter(i++, source);
+            }
+        }
+
+        return (Long) query.getSingleResult();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public List<Object[]> getRelationFacetCounts(Dataset d, DatasetVersion v, String groupBy,
+            List<String> relationTypeNames, List<String> datasetTypeNames, List<String> relationSources) {
+        boolean groupByDatasetType = "datasetType".equals(groupBy);
+        boolean needsRelationTypes = !groupByDatasetType || (relationTypeNames != null && !relationTypeNames.isEmpty());
+        boolean needsDatasetTypes = datasetTypeNames != null && !datasetTypeNames.isEmpty();
+        String select = groupByDatasetType
+                ? " SELECT CASE WHEN dr.relation_source = 'external' AND dt.id IS NULL THEN NULL ELSE dt.name END, "
+                        + "CASE WHEN dr.relation_source = 'external' AND dt.id IS NULL THEN dr.datasettype ELSE dt.displayname END, "
+                        + "CASE WHEN dr.relation_source = 'external' AND dt.id IS NULL THEN NULL ELSE dt.description END, COUNT(*) "
+                : " SELECT CASE WHEN dr.dataset_id = ? THEN rt.name ELSE inv.name END, "
+                        + "CASE WHEN dr.dataset_id = ? THEN rt.displayname ELSE inv.displayname END, "
+                        + "CASE WHEN dr.dataset_id = ? THEN rt.description ELSE inv.description END, COUNT(*) ";
+
+        StringBuilder sql = new StringBuilder();
+        sql.append(WITH_LATEST_RELEASED_VERSIONS)
+                .append(WITH_CANDIDATE_RELATIONS)
+                .append(WITH_DEDUPLICATED_RELATIONS)
+                .append(select)
+                .append(" FROM deduplicated_relations ddr JOIN datasetrelation dr ON ddr.id = dr.id ");
+        if (needsRelationTypes) {
+            sql.append(JOIN_RELATION_TYPES);
+        }
+        if (groupByDatasetType) {
+            sql.append(JOIN_DATASET_TYPES);
+        } else if (needsDatasetTypes) {
+            sql.append(JOIN_DATASET_TYPES);
+        }
+        sql.append(" WHERE 1 = 1 ");
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            sql.append(" AND ").append(WHERE_RELATION_TYPE_MATCHES.replace("(?)",
+                    "(" + relationTypeNames.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            sql.append(" AND ").append(WHERE_DATASET_TYPE_MATCHES.replace("(?)",
+                    "(" + datasetTypeNames.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+        if (relationSources != null && !relationSources.isEmpty()) {
+            sql.append(" AND ").append(WHERE_RELATION_SOURCE_MATCHES.replace("(?)",
+                    "(" + relationSources.stream().map(n -> "?").collect(Collectors.joining(",")) + ")"));
+        }
+        if (groupByDatasetType) {
+            sql.append(" AND (dr.relation_source = 'internal' OR dr.datasettype IS NOT NULL) ")
+                    .append(" GROUP BY 1, 2, 3 ORDER BY COUNT(*) DESC, 1 ASC ");
+        } else {
+            sql.append(" GROUP BY 1, 2, 3 ORDER BY COUNT(*) DESC, 1 ASC ");
+        }
+
+        Query query = em.createNativeQuery(sql.toString());
+        int i = 1;
+        query.setParameter(i++, v.getId());
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+        query.setParameter(i++, d.getId());
+        if (!groupByDatasetType) {
+            query.setParameter(i++, d.getId());
+            query.setParameter(i++, d.getId());
+            query.setParameter(i++, d.getId());
+        }
+        if (groupByDatasetType || needsDatasetTypes) {
+            query.setParameter(i++, d.getId());
+        }
+        if (relationTypeNames != null && !relationTypeNames.isEmpty()) {
+            query.setParameter(i++, d.getId());
+            for (String typeName : relationTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            query.setParameter(i++, d.getId());
+            for (String typeName : relationTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+        }
+        if (datasetTypeNames != null && !datasetTypeNames.isEmpty()) {
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+            for (String typeName : datasetTypeNames) {
+                query.setParameter(i++, typeName);
+            }
+        }
+        if (relationSources != null && !relationSources.isEmpty()) {
+            for (String source : relationSources) {
+                query.setParameter(i++, source);
+            }
+        }
+        return (List<Object[]>) query.getResultList();
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java
index 1945d44cd78..1ddc336710a 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java
@@ -3,10 +3,11 @@
 import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.dataset.DatasetFieldsValidator;
 import edu.harvard.iq.dataverse.authorization.providers.builtin.BuiltinUserServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationTypeServiceBean;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.license.LicenseServiceBean;
 import edu.harvard.iq.dataverse.search.IndexServiceBean;
-import edu.harvard.iq.dataverse.search.SearchService;
 import edu.harvard.iq.dataverse.search.SearchServiceFactory;
 import edu.harvard.iq.dataverse.actionlogging.ActionLogServiceBean;
 import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
@@ -126,6 +127,10 @@ public interface CommandContext {
 
     public DatasetTypeServiceBean datasetTypes();
 
+    public DatasetRelationServiceBean datasetRelations();
+
+    public DatasetRelationTypeServiceBean datasetRelationTypes();
+
     public void beginCommandSequence();
     
     public boolean completeCommandSequence(Command command);
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationCommand.java
new file mode 100644
index 00000000000..cac6d6a07c5
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationCommand.java
@@ -0,0 +1,53 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.DatasetVersion;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationIndexing;
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import jakarta.ejb.EJBException;
+
+import java.util.List;
+
+/**
+ * Creates a new relation for a given dataset.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@RequiredPermissions(Permission.EditDatasetRelations)
+public class CreateDatasetRelationCommand extends AbstractCommand<DatasetRelation> {
+    private final DatasetVersion version;
+
+    private final DatasetRelationDTO relationDTO;
+
+    public CreateDatasetRelationCommand(DatasetVersion version, DatasetRelationDTO relation, DataverseRequest aRequest) {
+        super(aRequest, version.getDataset());
+        this.version = version;
+        this.relationDTO = relation;
+    }
+
+    @Override
+    public DatasetRelation execute(CommandContext ctxt) throws CommandException {
+        try {
+            DatasetRelation relation = ctxt.datasetRelations().fromDTO(relationDTO, version);
+
+            if (relation == null) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.invalid"), this);
+            }
+            if (ctxt.datasetRelations().isDuplicate(relation)) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.duplicate"), this);
+            }
+
+            DatasetRelation addedRelation = ctxt.datasetRelations().addDatasetRelation(relation);
+            DatasetRelationIndexing.schedule(ctxt, version.getDataset(), List.of(addedRelation));
+            return addedRelation;
+        } catch (EJBException ex) {
+            throw new CommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.create"), ex, this);
+        }
+    }
+
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationTypeCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationTypeCommand.java
new file mode 100644
index 00000000000..ac8984f24aa
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDatasetRelationTypeCommand.java
@@ -0,0 +1,47 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.DvObject;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationTypeException;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.IllegalCommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import edu.harvard.iq.dataverse.util.json.JsonUtil;
+import jakarta.ejb.EJBException;
+import jakarta.json.JsonObject;
+import jakarta.persistence.PersistenceException;
+import jakarta.ws.rs.core.Response;
+import org.eclipse.persistence.exceptions.DatabaseException;
+
+/**
+ * A superuser-only command for creating new dataset relation types.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@RequiredPermissions({})
+public class CreateDatasetRelationTypeCommand extends AbstractVoidCommand {
+    private final DatasetRelationType relationType;
+
+    public CreateDatasetRelationTypeCommand(DataverseRequest request, DatasetRelationType relationType) {
+        super(request, (DvObject) null);
+        this.relationType = relationType;
+    }
+
+    @Override
+    protected void executeImpl(CommandContext ctxt) throws CommandException, InvalidCommandArgumentsException, IllegalCommandException {
+        if (!getUser().isSuperuser()) {
+            throw new IllegalCommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create.superuserOnly"), this);
+        }
+
+        try {
+            ctxt.datasetRelationTypes().save(relationType);
+        } catch (DatasetRelationTypeException ex) {
+            throw new InvalidCommandArgumentsException(ex.getMessage(), this);
+        } catch (EJBException ex) {
+            throw new CommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.create"), ex, this);
+        }
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationCommand.java
new file mode 100644
index 00000000000..ad5c906bc3c
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationCommand.java
@@ -0,0 +1,40 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationIndexing;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.PermissionException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Deletes a dataset relation.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@RequiredPermissions(Permission.EditDatasetRelations)
+public class DeleteDatasetRelationCommand extends AbstractVoidCommand {
+
+    private final DatasetRelation relation;
+
+    public DeleteDatasetRelationCommand(DataverseRequest request, DatasetRelation relation) {
+        super(request, relation.getDefinitionPoint().getDataset());
+        this.relation = relation;
+    }
+
+    @Override
+    protected void executeImpl(CommandContext ctxt) throws CommandException {
+        if (relation.getDefinitionPoint().isReleased()
+                && (!(getUser() instanceof AuthenticatedUser) || !getUser().isSuperuser())) {
+            throw new PermissionException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.editForbidden"),
+                    this, Collections.singleton(Permission.EditDatasetRelations), relation.getDefinitionPoint().getDataset());
+        }
+        ctxt.datasetRelations().deleteDatasetRelationById(relation.getId());
+        DatasetRelationIndexing.schedule(ctxt, relation.getDefinitionPoint().getDataset(), List.of(relation));
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationTypeCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationTypeCommand.java
new file mode 100644
index 00000000000..4666a103c49
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDatasetRelationTypeCommand.java
@@ -0,0 +1,50 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.DvObject;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationTypeException;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.IllegalCommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import edu.harvard.iq.dataverse.util.json.JsonUtil;
+import jakarta.ejb.EJBException;
+import jakarta.json.JsonObject;
+import jakarta.persistence.PersistenceException;
+import jakarta.ws.rs.core.Response;
+
+import java.text.MessageFormat;
+
+import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
+
+/**
+ * A superuser-only command for deleting dataset relation types.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@RequiredPermissions({})
+public class DeleteDatasetRelationTypeCommand extends AbstractVoidCommand {
+    private final DatasetRelationType relationType;
+
+    public DeleteDatasetRelationTypeCommand(DataverseRequest request, DatasetRelationType relationType) {
+        super(request, (DvObject) null);
+        this.relationType = relationType;
+    }
+
+    @Override
+    protected void executeImpl(CommandContext ctxt) throws IllegalCommandException, InvalidCommandArgumentsException, CommandException {
+        if (!getUser().isSuperuser()) {
+            throw new IllegalCommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.delete.superuserOnly"), this);
+        }
+
+        try {
+            ctxt.datasetRelationTypes().delete(relationType);
+        } catch (DatasetRelationTypeException ex) {
+            throw new InvalidCommandArgumentsException(ex.getMessage(), this);
+        } catch (EJBException ex) {
+            throw new CommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.delete"), ex, this);
+        }
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DestroyDatasetCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DestroyDatasetCommand.java
index 49861e084b6..cc11468e45a 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DestroyDatasetCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DestroyDatasetCommand.java
@@ -75,6 +75,10 @@ protected void executeImpl(CommandContext ctxt) throws CommandException {
                 this,  Collections.singleton(Permission.DeleteDatasetDraft), doomed);                
         }
         Dataset managedDoomed = ctxt.em().merge(doomed);
+
+        // Remove relations defined by this dataset and relations from other datasets targeting it.
+        // The latter are not removed by deleting this dataset's versions.
+        ctxt.datasetRelations().deleteAllDatasetRelationsInvolving(managedDoomed);
         
         // If there is a dedicated thumbnail DataFile, it needs to be reset
         // explicitly, or we'll get a constraint violation when deleting:
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/FinalizeDatasetPublicationCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/FinalizeDatasetPublicationCommand.java
index be47861316f..a929db9ae69 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/FinalizeDatasetPublicationCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/FinalizeDatasetPublicationCommand.java
@@ -17,7 +17,9 @@
 import edu.harvard.iq.dataverse.UserNotification;
 import edu.harvard.iq.dataverse.authorization.Permission;
 import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
 import edu.harvard.iq.dataverse.dataset.DatasetUtil;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationIndexing;
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
@@ -299,7 +301,13 @@ public boolean onSuccess(CommandContext ctxt, Object r) {
         // Metadata export:
         ctxt.datasets().reExportDatasetAsync(dataset);
         
-        ctxt.index().asyncIndexDataset(dataset, true);
+        DatasetVersion priorReleasedVersion = dataset.getPriorReleasedVersion();
+        List<DatasetRelation> currentRelations = ctxt.datasetRelations()
+                .getDatasetRelationsDefinedAt(dataset.getLatestVersion());
+        List<DatasetRelation> previousRelations = priorReleasedVersion == null
+                ? List.of()
+                : ctxt.datasetRelations().getDatasetRelationsDefinedAt(priorReleasedVersion);
+        DatasetRelationIndexing.scheduleChanges(ctxt, dataset, previousRelations, currentRelations);
         
         //re-indexing dataverses that have additional subjects
         if (!dataversesToIndex.isEmpty()){
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ReplaceDatasetRelationsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ReplaceDatasetRelationsCommand.java
new file mode 100644
index 00000000000..eff6beab6f8
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ReplaceDatasetRelationsCommand.java
@@ -0,0 +1,77 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationIndexing;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.ExternalDatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.InternalDatasetRelation;
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import jakarta.ejb.EJBException;
+
+import java.util.List;
+
+/**
+ * Replaces all relations defined for a given dataset.
+ *
+ * @author Vera Clemens (ZB MED)
+ */
+@RequiredPermissions(Permission.EditDatasetRelations)
+public class ReplaceDatasetRelationsCommand extends AbstractCommand<List<DatasetRelation>> {
+    private final DatasetVersion version;
+
+    private final List<DatasetRelationDTO> relationDTOs;
+
+    private final boolean replacePublishedVersionDirectly;
+
+    public ReplaceDatasetRelationsCommand(DatasetVersion version, List<DatasetRelationDTO> relations, DataverseRequest aRequest) {
+        this(version, relations, aRequest, false);
+    }
+
+    public ReplaceDatasetRelationsCommand(DatasetVersion version, List<DatasetRelationDTO> relations, DataverseRequest aRequest,
+            boolean replacePublishedVersionDirectly) {
+        super(aRequest, version.getDataset());
+        this.version = version;
+        this.relationDTOs = relations;
+        this.replacePublishedVersionDirectly = replacePublishedVersionDirectly;
+    }
+
+    @Override
+    public List<DatasetRelation> execute(CommandContext ctxt) throws CommandException {
+        try {
+            DatasetVersion effectiveVersion;
+
+            // Editing the latest published version creates an edit version, unless a superuser selected a published version explicitly.
+            if (!version.isDraft() && !replacePublishedVersionDirectly) {
+                effectiveVersion = version.getDataset().getOrCreateEditVersion();
+                ctxt.engine().submit(new UpdateDatasetVersionCommand(version.getDataset(), getRequest()));
+            } else {
+                effectiveVersion = version;
+            }
+
+            List<DatasetRelation> relations = relationDTOs.stream()
+                    .map(dto -> ctxt.datasetRelations().fromDTO(dto, effectiveVersion))
+                    .toList();
+            if (relations.contains(null)) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.invalid"), this);
+            }
+            if (ctxt.datasetRelations().containsDuplicates(relations)) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.duplicate"), this);
+            }
+            List<DatasetRelation> previousRelations = ctxt.datasetRelations().getDatasetRelationsDefinedAt(effectiveVersion);
+            List<DatasetRelation> addedRelations = ctxt.datasetRelations().replaceAllDatasetRelationsFor(effectiveVersion, relations);
+
+            DatasetRelationIndexing.scheduleChanges(ctxt, version.getDataset(), previousRelations, addedRelations);
+            return addedRelations;
+        } catch (EJBException ex) {
+            throw new CommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.replace"), ex, this);
+        }
+    }
+
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionCommand.java
index 1a3a55be4a0..34e642e121c 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionCommand.java
@@ -300,7 +300,7 @@ public boolean onSuccess(CommandContext ctxt, Object r) {
         // Indexing will be started immediately, unless an index is already busy for the given data
         // (it will be scheduled then for later indexing of the newest version).
         // See the documentation of asyncIndexDataset method for more details.
-        ctxt.index().asyncIndexDataset((Dataset) r, true);
+        ctxt.index().asyncIndexDataset(this.getDataset(), true);
         return true;
     }
     
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionWithRelationsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionWithRelationsCommand.java
new file mode 100644
index 00000000000..3f9e56e797f
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDatasetVersionWithRelationsCommand.java
@@ -0,0 +1,70 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetVersion;
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.IllegalCommandException;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccessValidator;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+
+import java.util.List;
+
+/**
+ * Atomically updates a draft version and, when supplied, replaces its relations.
+ */
+@RequiredPermissions(Permission.EditDataset)
+public class UpdateDatasetVersionWithRelationsCommand extends AbstractDatasetCommand<DatasetVersion> {
+
+    private final DatasetVersion incomingVersion;
+    private final List<DatasetRelationDTO> relationDTOs;
+
+    public UpdateDatasetVersionWithRelationsCommand(Dataset dataset, DatasetVersion incomingVersion,
+            List<DatasetRelationDTO> relationDTOs, DataverseRequest request) {
+        super(request, dataset);
+        this.incomingVersion = incomingVersion;
+        this.relationDTOs = relationDTOs;
+    }
+
+    @Override
+    public DatasetVersion execute(CommandContext ctxt) throws CommandException {
+        Dataset dataset = getDataset();
+        DatasetVersion managedVersion;
+
+        if (dataset.getLatestVersion().isDraft()) {
+            DatasetVersion editVersion = dataset.getOrCreateEditVersion();
+            editVersion.setDatasetFields(incomingVersion.getDatasetFields());
+            editVersion.setTermsOfUseAndAccess(incomingVersion.getTermsOfUseAndAccess());
+            editVersion.getTermsOfUseAndAccess().setDatasetVersion(editVersion);
+
+            if (!TermsOfUseAndAccessValidator.isTOUAValid(editVersion.getTermsOfUseAndAccess(), null)) {
+                throw new IllegalCommandException(BundleUtil.getStringFromBundle("dataset.message.toua.invalid"), this);
+            }
+
+            Dataset managedDataset = ctxt.engine().submit(new UpdateDatasetVersionCommand(dataset, getRequest()));
+            managedVersion = managedDataset.getOrCreateEditVersion();
+        } else {
+            if (relationDTOs == null && dataset.getLatestVersion().getRelations() != null) {
+                incomingVersion.setRelations(dataset.getLatestVersion().getRelations().stream()
+                        .map(relation -> relation.copy(incomingVersion))
+                        .toList());
+            }
+
+            if (!TermsOfUseAndAccessValidator.isTOUAValid(incomingVersion.getTermsOfUseAndAccess(), null)) {
+                throw new IllegalCommandException(BundleUtil.getStringFromBundle("dataset.message.toua.invalid"), this);
+            }
+
+            managedVersion = ctxt.engine().submit(new CreateDatasetVersionCommand(getRequest(), dataset, incomingVersion));
+        }
+
+        if (relationDTOs != null) {
+            ctxt.engine().submit(new ReplaceDatasetRelationsCommand(managedVersion, relationDTOs, getRequest()));
+        }
+
+        return managedVersion;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDefaultDatasetRelationTypeCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDefaultDatasetRelationTypeCommand.java
new file mode 100644
index 00000000000..895c049d393
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDefaultDatasetRelationTypeCommand.java
@@ -0,0 +1,32 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.DvObject;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.engine.command.AbstractVoidCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
+import edu.harvard.iq.dataverse.engine.command.exception.IllegalCommandException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+
+/**
+ * A superuser-only command for changing the default dataset relation type.
+ */
+@RequiredPermissions({})
+public class UpdateDefaultDatasetRelationTypeCommand extends AbstractVoidCommand {
+
+    private final DatasetRelationType relationType;
+
+    public UpdateDefaultDatasetRelationTypeCommand(DataverseRequest request, DatasetRelationType relationType) {
+        super(request, (DvObject) null);
+        this.relationType = relationType;
+    }
+
+    @Override
+    protected void executeImpl(CommandContext ctxt) throws IllegalCommandException {
+        if (!getUser().isSuperuser()) {
+            throw new IllegalCommandException(BundleUtil.getStringFromBundle("datasets.api.datasetRelationType.error.default.superuserOnly"), this);
+        }
+        ctxt.datasetRelationTypes().setDefault(relationType);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/pidproviders/doi/XmlMetadataTemplate.java b/src/main/java/edu/harvard/iq/dataverse/pidproviders/doi/XmlMetadataTemplate.java
index 954ddc46f36..ec88e2c44b0 100644
--- a/src/main/java/edu/harvard/iq/dataverse/pidproviders/doi/XmlMetadataTemplate.java
+++ b/src/main/java/edu/harvard/iq/dataverse/pidproviders/doi/XmlMetadataTemplate.java
@@ -32,7 +32,10 @@
 import org.ocpsoft.common.util.Strings;
 
 import edu.harvard.iq.dataverse.api.Util;
-import edu.harvard.iq.dataverse.dataset.DatasetType;
+import edu.harvard.iq.dataverse.dataset.DatasetType;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.InternalDatasetRelation;
 import edu.harvard.iq.dataverse.dataset.DatasetUtil;
 import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.pidproviders.AbstractPidProvider;
@@ -1011,7 +1014,7 @@ private void writeRelatedIdentifiers(XMLStreamWriter xmlw, DvObject dvObject) th
 
         if (dvObject instanceof Dataset dataset) {
             List<DatasetRelPublication> relatedPublications = dataset.getLatestVersionForCopy().getRelatedPublications();
-            if (!relatedPublications.isEmpty()) {
+            if (!relatedPublications.isEmpty()) {
                 for (DatasetRelPublication relatedPub : relatedPublications) {
                     attributes.clear();
 
@@ -1119,9 +1122,32 @@ private void writeRelatedIdentifiers(XMLStreamWriter xmlw, DvObject dvObject) th
                         relatedIdentifiersWritten = XmlWriterUtil.writeOpenTagIfNeeded(xmlw, "relatedIdentifiers", relatedIdentifiersWritten);
                         XmlWriterUtil.writeFullElementWithAttributes(xmlw, "relatedIdentifier", attributes, relatedIdentifier);
                     }
-                }
-            }
-            List<FileMetadata> fmds = dataset.getLatestVersionForCopy().getFileMetadatas();
+                }
+            }
+            List<DatasetRelation> datasetRelations = dataset.getLatestVersionForCopy().getRelations();
+            if (datasetRelations != null) {
+                for (DatasetRelation relation : datasetRelations) {
+                    if (!(relation instanceof InternalDatasetRelation internalRelation)
+                            || !isDataCiteRelationType(relation.getRelationType())) {
+                        continue;
+                    }
+                    GlobalId relatedDatasetId = internalRelation.getRelatedDataset().getGlobalId();
+                    if (relatedDatasetId == null) {
+                        continue;
+                    }
+                    String relatedIdentifierType = getCanonicalPublicationType(relatedDatasetId.getProtocol());
+                    if (relatedIdentifierType == null) {
+                        continue;
+                    }
+                    attributes.clear();
+                    attributes.put("relationType", relation.getRelationType().getName());
+                    attributes.put("relatedIdentifierType", relatedIdentifierType);
+                    relatedIdentifiersWritten = XmlWriterUtil.writeOpenTagIfNeeded(xmlw, "relatedIdentifiers", relatedIdentifiersWritten);
+                    XmlWriterUtil.writeFullElementWithAttributes(xmlw, "relatedIdentifier", attributes,
+                            relatedDatasetId.asRawIdentifier());
+                }
+            }
+            List<FileMetadata> fmds = dataset.getLatestVersionForCopy().getFileMetadatas();
             if (!((fmds==null) && fmds.isEmpty())) {
                 attributes.clear();
                 attributes.put("relationType", "HasPart");
@@ -1159,7 +1185,7 @@ private void writeRelatedIdentifiers(XMLStreamWriter xmlw, DvObject dvObject) th
 
     static HashMap<String, String> relatedIdentifierTypeMap = new HashMap<String, String>();
 
-    private static String getCanonicalPublicationType(String pubIdType) {
+    private static String getCanonicalPublicationType(String pubIdType) {
         if (relatedIdentifierTypeMap.isEmpty()) {
             relatedIdentifierTypeMap.put("ARK".toLowerCase(), "ARK");
             relatedIdentifierTypeMap.put("arXiv", "arXiv");
@@ -1186,8 +1212,28 @@ private static String getCanonicalPublicationType(String pubIdType) {
             relatedIdentifierTypeMap.put("perma".toLowerCase(), "URL");
             
         }
-        return relatedIdentifierTypeMap.get(pubIdType);
-    }
+        return relatedIdentifierTypeMap.get(pubIdType);
+    }
+
+    private static boolean isDataCiteRelationType(DatasetRelationType relationType) {
+        try {
+            DataCiteRelationType.valueOf(relationType.getName());
+            return true;
+        } catch (IllegalArgumentException ex) {
+            return false;
+        }
+    }
+
+    /** The DataCite Metadata Schema 4.5 controlled list for relationType. */
+    private enum DataCiteRelationType {
+        IsCitedBy, Cites, IsSupplementTo, IsSupplementedBy, IsContinuedBy, Continues,
+        IsDescribedBy, Describes, HasMetadata, IsMetadataFor, HasVersion, IsVersionOf,
+        IsNewVersionOf, IsPreviousVersionOf, IsPartOf, HasPart, IsPublishedIn,
+        IsReferencedBy, References, IsDocumentedBy, Documents, IsCompiledBy, Compiles,
+        IsVariantFormOf, IsOriginalFormOf, IsIdenticalTo, IsReviewedBy, Reviews,
+        IsDerivedFrom, IsSourceOf, IsRequiredBy, Requires, IsObsoletedBy, Obsoletes,
+        IsCollectedBy, Collects
+    }
 
     private void writeSize(XMLStreamWriter xmlw, DvObject dvObject) throws XMLStreamException {
         // sizes -> size
@@ -1752,4 +1798,4 @@ private void writeFundingReferences(XMLStreamWriter xmlw, DvObject dvObject) thr
 
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java
index 8132c5e113d..24b37e0aeef 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java
@@ -38,6 +38,7 @@
 import edu.harvard.iq.dataverse.dataaccess.DataAccess;
 import edu.harvard.iq.dataverse.dataaccess.DataAccessRequest;
 import edu.harvard.iq.dataverse.dataaccess.StorageIO;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.datavariable.DataVariable;
 import edu.harvard.iq.dataverse.datavariable.VariableMetadata;
@@ -93,7 +94,6 @@
 import jakarta.json.JsonObject;
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.PersistenceContext;
-import jakarta.persistence.Query;
 
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -134,6 +134,8 @@ public class IndexServiceBean {
     @EJB
     DatasetVersionServiceBean datasetVersionService;
     @EJB
+    DatasetRelationServiceBean datasetRelationService;
+    @EJB
     BuiltinUserServiceBean dataverseUserServiceBean;
     @EJB
     PermissionServiceBean permissionService;
@@ -1070,6 +1072,8 @@ public SolrInputDocuments toSolrDocs(IndexableDataset indexableDataset, Set<Long
         String parentDatasetTitle = "TBD";
         if (datasetVersion != null) {
 
+            solrInputDocument.addField(SearchFields.RELATED_DATASET_COUNT, datasetRelationService.getTotalDatasetRelationCountFor(dataset, datasetVersion));
+
             addLicenseToSolrDoc(solrInputDocument, datasetVersion);
 
             solrInputDocument.addField(SearchFields.DATASET_VERSION_ID, datasetVersion.getId());
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/SearchFields.java b/src/main/java/edu/harvard/iq/dataverse/search/SearchFields.java
index c6d6d470060..ca3af4a812a 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/SearchFields.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/SearchFields.java
@@ -301,7 +301,9 @@ more targeted results for just datasets. The format is YYYY (i.e.
     public static final String DATASET_VALID = "datasetValid";
 
     public static final String DATASET_LICENSE = "license";
+
     public static final String FILE_COUNT = "fileCount";
     public static final String DATASET_COUNT = "datasetCount";
+    public static final String RELATED_DATASET_COUNT = "relatedDatasetCount";
 
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchResult.java b/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchResult.java
index 0f38698cbad..719185dac87 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchResult.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchResult.java
@@ -85,6 +85,10 @@ public class SolrSearchResult {
     * Only Dataset can have a file count
     */
     private Long fileCount;
+    /**
+     * Only Datasets can have a related dataset count
+     */
+    private Long relatedDatasetCount;
     /**
      * Only Dataverses can have a dataset count
      */
@@ -627,7 +631,7 @@ public JsonObjectBuilder json(boolean showRelevance, boolean showEntityIds, bool
                 }
                 nullSafeJsonBuilder.add("subjects", subjects);
                 nullSafeJsonBuilder.add("fileCount", this.fileCount);
-                nullSafeJsonBuilder.add("versionId", dv.getId());
+                nullSafeJsonBuilder.add("relatedDatasetCount", this.relatedDatasetCount);nullSafeJsonBuilder.add("versionId", dv.getId());
                 nullSafeJsonBuilder.add("versionState", dv.getVersionState().toString());
                 if (this.isPublishedState()) {
                     nullSafeJsonBuilder.add("majorVersion", dv.getVersionNumber());
@@ -1446,4 +1450,12 @@ public boolean isLocallyFAIR() {
         return locallyFAIR;
     }
 
+    public Long getRelatedDatasetCount() {
+        return relatedDatasetCount;
+    }
+
+    public void setRelatedDatasetCount(Long relatedDatasetCount) {
+        this.relatedDatasetCount = relatedDatasetCount;
+    }
+
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchServiceBean.java
index 401bd58a70b..2a1efa2bfcb 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/SolrSearchServiceBean.java
@@ -463,6 +463,7 @@ public SolrQueryResponse search(
             Boolean datasetValid = (Boolean) solrDocument.getFieldValue(SearchFields.DATASET_VALID);
             Long fileCount = (Long) solrDocument.getFieldValue(SearchFields.FILE_COUNT);
             Long datasetCount = (Long) solrDocument.getFieldValue(SearchFields.DATASET_COUNT);
+            Long relatedDatasetCount = (Long) solrDocument.getFieldValue(SearchFields.RELATED_DATASET_COUNT);
 
             Boolean locallyFAIR = (Boolean) solrDocument.getFieldValue(SearchFields.LOCALLY_FAIR);
 
@@ -540,6 +541,7 @@ public SolrQueryResponse search(
             solrSearchResult.setDatasetValid(datasetValid);
             solrSearchResult.setFileCount(fileCount);
             solrSearchResult.setDatasetCount(datasetCount);
+            solrSearchResult.setRelatedDatasetCount(relatedDatasetCount);
 
             if (Boolean.TRUE.equals((Boolean) solrDocument.getFieldValue(SearchFields.IS_HARVESTED))) {
                 solrSearchResult.setHarvested(true);
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
index 896c2510688..17dc22dd080 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
@@ -3,6 +3,7 @@
 import com.google.gson.Gson;
 import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.api.Util;
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
 import edu.harvard.iq.dataverse.api.dto.DataverseDTO;
 import edu.harvard.iq.dataverse.api.dto.FieldDTO;
 import edu.harvard.iq.dataverse.api.dto.UserDTO;
@@ -10,6 +11,8 @@
 import edu.harvard.iq.dataverse.authorization.groups.impl.ipaddress.ip.IpAddress;
 import edu.harvard.iq.dataverse.authorization.groups.impl.ipaddress.ip.IpAddressRange;
 import edu.harvard.iq.dataverse.authorization.groups.impl.maildomain.MailDomainGroup;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
 import edu.harvard.iq.dataverse.datasetutility.OptionalFileParams;
@@ -50,6 +53,7 @@ public class JsonParser {
     LicenseServiceBean licenseService;
     DatasetTypeServiceBean datasetTypeService;
     TemplateServiceBean templateService;
+    DatasetRelationServiceBean datasetRelationService;
     HarvestingClient harvestingClient = null;
     boolean allowHarvestingMissingCVV = false;
 
@@ -66,15 +70,16 @@ public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceB
     }
 
     public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceBean blockService, SettingsServiceBean settingsService, LicenseServiceBean licenseService, DatasetTypeServiceBean datasetTypeService, TemplateServiceBean templateService) {
-        this(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, null, templateService);
+        this(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, datasetRelationService, null, templateService);
     }
 
-    public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceBean blockService, SettingsServiceBean settingsService, LicenseServiceBean licenseService, DatasetTypeServiceBean datasetTypeService, HarvestingClient harvestingClient, TemplateServiceBean templateService) {
+    public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceBean blockService, SettingsServiceBean settingsService, LicenseServiceBean licenseService, DatasetTypeServiceBean datasetTypeService, DatasetRelationServiceBean datasetRelationService, HarvestingClient harvestingClient, TemplateServiceBean templateService) {
         this.datasetFieldSvc = datasetFieldSvc;
         this.blockService = blockService;
         this.settingsService = settingsService;
         this.licenseService = licenseService;
         this.datasetTypeService = datasetTypeService;
+        this.datasetRelationService = datasetRelationService;
         this.harvestingClient = harvestingClient;
         this.templateService = templateService;
         this.allowHarvestingMissingCVV = harvestingClient != null && harvestingClient.getAllowHarvestingMissingCVV();
@@ -179,10 +184,10 @@ public Dataverse parseDataverse(JsonObject jobj) throws JsonParseException {
     public DataverseDTO parseDataverseDTO(JsonObject jsonObject) throws JsonParseException {
         DataverseDTO dataverseDTO = new DataverseDTO();
 
-        setDataverseDTOPropertyIfPresent(jsonObject, "alias", dataverseDTO::setAlias);
-        setDataverseDTOPropertyIfPresent(jsonObject, "name", dataverseDTO::setName);
-        setDataverseDTOPropertyIfPresent(jsonObject, "description", dataverseDTO::setDescription);
-        setDataverseDTOPropertyIfPresent(jsonObject, "affiliation", dataverseDTO::setAffiliation);
+        setDTOPropertyIfPresent(jsonObject, "alias", dataverseDTO::setAlias);
+        setDTOPropertyIfPresent(jsonObject, "name", dataverseDTO::setName);
+        setDTOPropertyIfPresent(jsonObject, "description", dataverseDTO::setDescription);
+        setDTOPropertyIfPresent(jsonObject, "affiliation", dataverseDTO::setAffiliation);
 
         String dataverseType = jsonObject.getString("dataverseType", null);
         if (dataverseType != null) {
@@ -211,13 +216,30 @@ public DataverseDTO parseDataverseDTO(JsonObject jsonObject) throws JsonParseExc
         return dataverseDTO;
     }
 
-    private void setDataverseDTOPropertyIfPresent(JsonObject jsonObject, String key, Consumer<String> setter) {
+    private void setDTOPropertyIfPresent(JsonObject jsonObject, String key, Consumer<String> setter) {
         String value = jsonObject.getString(key, null);
         if (value != null) {
             setter.accept(value);
         }
     }
 
+    public DatasetRelationDTO parseDatasetRelationDTO(JsonObject jsonObject) {
+        DatasetRelationDTO datasetRelationDTO = new DatasetRelationDTO();
+
+        setDTOPropertyIfPresent(jsonObject, "relatedDatasetPid", datasetRelationDTO::setRelatedDatasetPid);
+        setDTOPropertyIfPresent(jsonObject, "externalIdentifier", datasetRelationDTO::setExternalIdentifier);
+        setDTOPropertyIfPresent(jsonObject, "identifierScheme", datasetRelationDTO::setIdentifierScheme);
+
+        if (jsonObject.containsKey("relationType") && jsonObject.get("relationType").getValueType() == ValueType.OBJECT) {
+            setDTOPropertyIfPresent(jsonObject.getJsonObject("relationType"), "name", datasetRelationDTO::setRelationTypeName);
+        }
+        if (jsonObject.containsKey("relatedDatasetType") && jsonObject.get("relatedDatasetType").getValueType() == ValueType.OBJECT) {
+            setDTOPropertyIfPresent(jsonObject.getJsonObject("relatedDatasetType"), "displayName", datasetRelationDTO::setDatasetType);
+        }
+
+        return datasetRelationDTO;
+    }
+
     public DataverseTheme parseDataverseTheme(JsonObject obj) {
 
         DataverseTheme theme = new DataverseTheme();
@@ -436,6 +458,10 @@ public Dataset parseDataset(JsonObject obj, Dataverse owner) throws JsonParseExc
         DatasetVersion dsv = new DatasetVersion();
         dsv.setDataset(dataset);
         dsv = parseDatasetVersion(obj.getJsonObject("datasetVersion"), dsv);
+        List<DatasetRelation> relations = parseDatasetRelations(obj.getJsonObject("datasetVersion"), dsv);
+        if (relations != null) {
+            dsv.setRelations(relations);
+        }
         List<DatasetVersion> versions = new ArrayList<>(1);
         versions.add(dsv);
 
@@ -490,7 +516,7 @@ public DatasetVersion parseDatasetVersion(JsonObject obj, DatasetVersion dsv) th
 
             if (obj.containsKey("license")) {
                 try {
-                    // This method will attempt to parse the license in the format 
+                    // This method will attempt to parse the license in the format
                     // in which it appears in our json exports, as a compound
                     // field, for ex.:
                     // "license": {
@@ -500,10 +526,10 @@ public DatasetVersion parseDatasetVersion(JsonObject obj, DatasetVersion dsv) th
                     license = parseLicense(obj.getJsonObject("license"));
                 } catch (ClassCastException cce) {
                     logger.fine("class cast exception parsing the license section (will try parsing as a string)");
-                    // attempt to parse as string: 
+                    // attempt to parse as string:
                     // i.e. this is for backward compatibility, after the bug in #9155
-                    // was fixed, with the old style of encoding the license info 
-                    // in input json, for ex.: 
+                    // was fixed, with the old style of encoding the license info
+                    // in input json, for ex.:
                     // "license" : "CC0 1.0"
                     license = parseLicense(obj.getString("license", null));
                 }
@@ -580,6 +606,7 @@ public DatasetVersion parseDatasetVersion(JsonObject obj, DatasetVersion dsv) th
             if (filesJson != null) {
                 dsv.setFileMetadatas(parseFiles(filesJson, dsv));
             }
+
             return dsv;
         } catch (ParseException ex) {
             throw new JsonParseException(BundleUtil.getStringFromBundle("jsonparser.error.parsing.date", Arrays.asList(ex.getMessage())) , ex);
@@ -588,6 +615,32 @@ public DatasetVersion parseDatasetVersion(JsonObject obj, DatasetVersion dsv) th
         }
     }
 
+    public List<DatasetRelationDTO> parseDatasetRelationDTOs(JsonObject obj) {
+        JsonArray relationsJson = obj.getJsonArray("relations");
+        if (relationsJson == null) {
+            return null;
+        }
+        return relationsJson.getValuesAs(JsonObject.class).stream()
+                .map(this::parseDatasetRelationDTO)
+                .toList();
+    }
+
+    public List<DatasetRelation> parseDatasetRelations(JsonObject obj, DatasetVersion dsv) throws JsonParseException {
+        List<DatasetRelationDTO> relationDTOs = parseDatasetRelationDTOs(obj);
+        if (relationDTOs == null) {
+            return null;
+        }
+        List<DatasetRelation> relations = new ArrayList<>();
+        for (DatasetRelationDTO relationDTO : relationDTOs) {
+            DatasetRelation relation = datasetRelationService.fromDTO(relationDTO, dsv);
+            if (relation == null) {
+                throw new JsonParseException(BundleUtil.getStringFromBundle("datasets.api.datasetRelation.error.invalid"));
+            }
+            relations.add(relation);
+        }
+        return relations;
+    }
+
     public Guestbook parseGuestbook(JsonObject obj, Guestbook gb) throws JsonParseException {
         try {
             if (obj.containsKey("id")) {
@@ -792,7 +845,7 @@ public List<DatasetField> parseMetadataBlocks(JsonObject json) throws JsonParseE
         }
         return fields;
     }
-    
+
     public Map<String, String> parseRequestBodyInstructionsMap(JsonObject jsonObject) {
         Map<String, String> instructionsMap = new HashMap<>();
         JsonArray instructionsJsonArray = jsonObject.getJsonArray("instructions");
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
index 160e226f04e..51a9db7dc7a 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
@@ -18,8 +18,11 @@
 import edu.harvard.iq.dataverse.branding.BrandingUtil;
 import edu.harvard.iq.dataverse.dataaccess.DataAccess;
 import edu.harvard.iq.dataverse.dataaccess.StorageIO;
-import edu.harvard.iq.dataverse.dataset.DatasetType;
-import edu.harvard.iq.dataverse.dataset.DatasetUtil;
+import edu.harvard.iq.dataverse.dataset.*;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.ExternalDatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.InternalDatasetRelation;
 import edu.harvard.iq.dataverse.datasetversionsummaries.*;
 import edu.harvard.iq.dataverse.datavariable.*;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
@@ -308,12 +311,12 @@ public static JsonObjectBuilder json(Workflow wf){
 
         return bld;
     }
-    
+
     public static JsonObjectBuilder json(Dataverse dv, boolean minimal) {
         if (!minimal){
             return json(dv, false, false, false, null);
         } else {
-            return json(dv, false, false, true, null);        
+            return json(dv, false, false, true, null);
         }
     }
 
@@ -327,7 +330,7 @@ public static JsonObjectBuilder json(Dataverse dv, Boolean hideEmail, Boolean re
                 .add("id", dv.getId())
                 .add("alias", dv.getAlias())
                 .add("name", dv.getName());
-        //minimal refers to only returning the id alias and name for 
+        //minimal refers to only returning the id alias and name for
         //used in selecting collections available for linking
         if (minimal) {
             return bld;
@@ -652,22 +655,25 @@ public static JsonObjectBuilder json(FileDetailsHolder ds) {
     }
 
     public static JsonObjectBuilder json(DatasetVersion dsv, boolean includeFiles) {
-        return json(dsv, null, includeFiles, false, true, false, false);
+        return json(dsv, null, includeFiles, true, false, true, false, false);
     }
     public static JsonObjectBuilder json(DatasetVersion dsv, boolean includeFiles, boolean includeMetadataBlocks) {
-        return json(dsv, null, includeFiles, false, includeMetadataBlocks, false, false);
+        return json(dsv, null, includeFiles, true, false, includeMetadataBlocks, false, false);
     }
     public static JsonObjectBuilder json(DatasetVersion dsv, List<String> anonymizedFieldTypeNamesList,
                                          boolean includeFiles, boolean returnOwners) {
-        return  json(dsv, anonymizedFieldTypeNamesList, includeFiles, returnOwners, true, false, false);
+        return  json(dsv, anonymizedFieldTypeNamesList, includeFiles, true, returnOwners, true, false, false);
+    }
+    public static JsonObjectBuilder json(DatasetVersion dsv, boolean includeFiles, boolean includeMetadataBlocks, boolean includeRelations) {
+        return json(dsv, null, includeFiles, includeRelations, false, includeMetadataBlocks, false, false);
     }
     public static JsonObjectBuilder json(DatasetVersion dsv, List<String> anonymizedFieldTypeNamesList,
         boolean includeFiles, boolean returnOwners, boolean includeMetadataBlocks) {
-        return json(dsv,  anonymizedFieldTypeNamesList, includeFiles,  returnOwners, includeMetadataBlocks, false, false);
+        return json(dsv,  anonymizedFieldTypeNamesList, includeFiles, true, returnOwners, includeMetadataBlocks, false, false);
     }
 
     public static JsonObjectBuilder json(DatasetVersion dsv, List<String> anonymizedFieldTypeNamesList,
-        boolean includeFiles, boolean returnOwners, boolean includeMetadataBlocks, boolean forExportDataProvider, boolean ignoreSettingExcludeEmailFromExport) {
+        boolean includeFiles, boolean includeRelations, boolean returnOwners, boolean includeMetadataBlocks, boolean forExportDataProvider, boolean ignoreSettingExcludeEmailFromExport) {
         Dataset dataset = dsv.getDataset();
         JsonObjectBuilder bld = jsonObjectBuilder()
                 .add("id", dsv.getId()).add("datasetId", dataset.getId())
@@ -728,6 +734,9 @@ public static JsonObjectBuilder json(DatasetVersion dsv, List<String> anonymized
         if (includeFiles) {
             bld.add("files", jsonFileMetadatas(dsv.getFileMetadatas(), forExportDataProvider));
         }
+        if (includeRelations) {
+            bld.add("relations", json(dsv.getRelations(), dsv.getDataset(), false));
+        }
 
         return bld;
     }
@@ -754,19 +763,19 @@ public static JsonObjectBuilder jsonDataFileList(List<DataFile> dataFiles){
     public static JsonObjectBuilder datasetAsJsonForDTO(DatasetVersion dsv) {
         return datasetAsJsonForDTO(dsv, true);
     }
-    
+
     /**
      * Same as above, but gives an option to skip the file-level info
      * @param dsv
      * @param includeFiles
-     * @return 
+     * @return
      */
     public static JsonObjectBuilder datasetAsJsonForDTO(DatasetVersion dsv, boolean includeFiles) {
         JsonObjectBuilder jsonForDTO = JsonPrinter.json(dsv.getDataset());
         jsonForDTO.add("datasetVersion", versionAsJsonForDTO(dsv, includeFiles));
         return jsonForDTO;
     }
-    
+
     /**
      * Export formats such as DDI require the citation to be included. See
      * https://github.com/IQSS/dataverse/issues/2579 for more on DDI export.
@@ -784,7 +793,7 @@ private static JsonObjectBuilder versionAsJsonForDTO(DatasetVersion dsv, boolean
     public static JsonArrayBuilder jsonFileMetadatas(Collection<FileMetadata> fmds) {
         return jsonFileMetadatas(fmds, false);
     }
-    
+
     public static JsonArrayBuilder jsonFileMetadatas(Collection<FileMetadata> fmds, boolean forExportDataProvider) {
         JsonArrayBuilder filesArr = JsonUtil.createArrayBuilder();
         for (FileMetadata fmd : fmds) {
@@ -1013,7 +1022,7 @@ public static JsonObjectBuilder json(FileMetadata fmd){
     public static JsonObjectBuilder json(FileMetadata fmd, boolean returnOwners, boolean printDatasetVersion) {
         return json(fmd, returnOwners, printDatasetVersion, false);
     }
-    
+
     public static JsonObjectBuilder json(FileMetadata fmd, boolean returnOwners, boolean printDatasetVersion, boolean forExportDataProvider) {
         NullSafeJsonBuilder builder = jsonObjectBuilder();
 
@@ -1067,7 +1076,7 @@ public static JsonObjectBuilder json(DataFile df, FileMetadata fileMetadata, boo
     public static JsonObjectBuilder jsonDatafileWithDatatableForExport(DataFile df, FileMetadata fileMetadata) {
         return json(df, fileMetadata, true, false, true);
     }
-    
+
     public static JsonObjectBuilder json(DataFile df, FileMetadata fileMetadata, boolean forExportDataProvider, boolean returnOwners, boolean includeVariables) {
         String fileName = null;
 
@@ -1151,6 +1160,83 @@ public static JsonObjectBuilder json(DataFile df, FileMetadata fileMetadata, boo
         return builder;
     }
 
+    public static JsonObjectBuilder json(DatasetRelationType drt, boolean includeInverse) {
+        JsonObjectBuilder result = new NullSafeJsonBuilder();
+        result.add("name", drt.getName())
+                .add("displayName", drt.getDisplayName())
+                .add("description", drt.getDescription())
+                .add("default", drt.isDefault());
+        if (includeInverse && drt.getInverse() != null) {
+            result.add("inverse", json(drt.getInverse(), false));
+        }
+        return result;
+    }
+
+    public static JsonObjectBuilder json(DatasetRelationType drt) {
+        return json(drt, true);
+    }
+
+    public static JsonObjectBuilder json(DatasetRelation rel, boolean invertRelation, boolean includeMetadataBlocks) {
+        JsonObjectBuilder result = new NullSafeJsonBuilder();
+
+        result.add("id", rel.getId())
+              .add("definitionPointPid", rel.getDefinitionPoint().getDataset().getGlobalId().toString());
+
+        if (rel instanceof InternalDatasetRelation) {
+            InternalDatasetRelation irel = (InternalDatasetRelation) rel;
+            Dataset dataset = invertRelation ? irel.getRelatedDataset() : irel.getDataset();
+            Dataset relatedDataset = invertRelation ? irel.getDataset() : irel.getRelatedDataset();
+
+            result.add("datasetPid", dataset.getGlobalId().toString())
+                  .add("relatedDatasetPid", relatedDataset.getGlobalId().toString())
+                  .add("relatedDatasetType",
+                          Json.createObjectBuilder()
+                                  .add("name", relatedDataset.getDatasetType().getName())
+                                  .add("displayName", relatedDataset.getDatasetType().getDisplayName()));
+
+            if (includeMetadataBlocks) {
+                DatasetVersion releasedVersion = relatedDataset.getReleasedVersion();
+                if (releasedVersion != null) {
+                    result.add("relatedDataset",
+                            Json.createObjectBuilder().add("metadataBlocks", jsonByBlocks(releasedVersion.getDatasetFields()))
+                    );
+                }
+            }
+        } else if (rel instanceof ExternalDatasetRelation) {
+            ExternalDatasetRelation erel = (ExternalDatasetRelation) rel;
+            result.add("datasetPid", erel.getDataset().getGlobalId().toString())
+                  .add("externalIdentifier", erel.getExternalIdentifier())
+                  .add("identifierScheme", erel.getIdentifierScheme());
+
+            if (erel.getDatasetType() != null) {
+                  result.add("relatedDatasetType",
+                        Json.createObjectBuilder().add("displayName", erel.getDatasetType()));
+            }
+        }
+
+        if (rel.getRelationType() != null) {
+            DatasetRelationType relType = invertRelation ? rel.getRelationType().getInverse() : rel.getRelationType();
+            if (relType != null) {
+                result.add("relationType", json(relType));
+            }
+        }
+
+        return result;
+    }
+
+    public static JsonObjectBuilder json(DatasetRelation rel, Dataset forDataset, boolean includeMetadataBlocks) {
+        boolean invertRelation = false;
+        if (rel instanceof InternalDatasetRelation) {
+            InternalDatasetRelation internalRel = (InternalDatasetRelation) rel;
+            invertRelation = !internalRel.getDataset().equals(forDataset) && internalRel.getRelatedDataset().equals(forDataset);
+        }
+        return json(rel, invertRelation, includeMetadataBlocks);
+    }
+
+    public static JsonArrayBuilder json(List<DatasetRelation> rel, Dataset forDataset, boolean includeMetadataBlocks) {
+        return rel.stream().map(r -> json(r, forDataset, includeMetadataBlocks)).collect(toJsonArray());
+    }
+
     //Started from https://github.com/RENCI-NRIG/dataverse/, i.e. https://github.com/RENCI-NRIG/dataverse/commit/2b5a1225b42cf1caba85e18abfeb952171c6754a
     public static JsonArrayBuilder jsonDT(List<DataTable> ldt, boolean includeVariables) {
         JsonArrayBuilder ldtArr = JsonUtil.createArrayBuilder();
@@ -1903,7 +1989,7 @@ public static JsonArrayBuilder json(List<UserNotification> notifications, Authen
 
         return notificationsArray;
     }
-    
+
     public static JsonObjectBuilder jsonLanguage(String locale, String title) {
         // returns a single metadata language entry
         return jsonObjectBuilder().add("locale", locale).add("title", title);
@@ -1913,7 +1999,7 @@ public static JsonArrayBuilder jsonLanguage(Map<String, String> langMap) {
         // returns an array of metadatalanguages
         return JsonUtil.createArrayBuilder(langMap.entrySet().stream().map(entry -> jsonLanguage(entry.getKey(), entry.getValue())).toList());
     }
-    
+
     public static JsonArrayBuilder jsonDatasetVersionSummaries(List<DatasetVersionSummary> summaries) {
         JsonArrayBuilder arrayBuilder = JsonUtil.createArrayBuilder();
         summaries.stream()
diff --git a/src/main/java/propertyFiles/Bundle.properties b/src/main/java/propertyFiles/Bundle.properties
index 66dd1d1d659..8229dd3c4fc 100644
--- a/src/main/java/propertyFiles/Bundle.properties
+++ b/src/main/java/propertyFiles/Bundle.properties
@@ -2444,6 +2444,8 @@ find.dataset.error.dataset_id_is_null=When accessing a dataset based on Persiste
 find.dataset.error.dataset.not.found.persistentId=Dataset with Persistent ID {0} not found.
 find.dataset.error.dataset.not.found.id=Dataset with ID {0} not found.
 find.dataset.error.dataset.not.found.bad.id=Bad dataset ID number: {0}.
+find.datasetrelation.error.datasetrelation.not.found.id=Dataset relation with ID {0} not found.
+find.datasetrelation.error.datasetrelation.not.found.bad.id=Bad dataset relation ID number: {0}.
 find.datasetlinking.error.not.found.ids=Dataset linking dataverse with dataset ID {0} and dataset linking dataverse ID {1} not found.
 find.datasetlinking.error.not.found.bad.ids=Bad dataset ID number: {0} or dataset linking dataverse ID number: {1}.
 find.dataverselinking.error.not.found.ids=Dataverse linking dataverse with dataverse ID {0} and dataverse linking dataverse ID {1} not found.
@@ -2613,6 +2615,7 @@ permission.managePermissionsDataFile=Manage permissions for a file
 permission.managePermissionsDataset=Manage permissions for a dataset
 permission.managePermissionsDataverse=Manage permissions for a dataverse
 permission.editDataset=Edit a dataset's metadata, license, terms and add/delete files
+permission.editDatasetRelations=Create, replace, and delete dataset relations
 permission.editDataverse=Edit a dataverse's metadata, facets, customization, and templates 
 permission.downloadFile=Download a file
 permission.viewUnpublishedDataset=View an unpublished dataset and its files
@@ -2907,6 +2910,33 @@ datasets.api.citation.invalidFormat=Invalid Format Requested.
 datasets.api.updateLicense.success=Dataset license updated.
 datasets.api.updateLicense.licenseNotFound=License with name {0} not found.
 datasets.api.updateLicense.licenseNameIsEmpty=License name cannot be empty.
+datasets.api.datasetRelation.delete.success=Dataset relation successfully deleted.
+datasets.api.datasetRelation.error.jsonparse=Error parsing Json: {0}
+datasets.api.datasetRelation.error.jsonparsetodatasetrelation=Error parsing the submitted json into a dataset relation: {0}
+datasets.api.datasetRelation.error.editForbidden=You are not permitted to edit the dataset relations of a published version of a dataset.
+datasets.api.datasetRelation.error.editNotAuthorized=You are not permitted to edit dataset relations.
+datasets.api.datasetRelation.error.viewForbidden=You are not permitted to view this dataset relation.
+datasets.api.datasetRelation.error.datasetVersionNotFound=Latest accessible version not found for dataset {0}.
+datasets.api.datasetRelation.error.create=Something went wrong. Dataset relation could not be created.
+datasets.api.datasetRelation.error.replace=Something went wrong. Dataset relations could not be replaced.
+datasets.api.datasetRelation.error.invalid=Dataset relation could not be created from the submitted data.
+datasets.api.datasetRelation.error.duplicate=A dataset relation with these endpoints already exists.
+datasets.api.datasetRelationType.create.success=Relation type(s) successfully created.
+datasets.api.datasetRelationType.delete.success=Relation type successfully deleted.
+datasets.api.datasetRelationType.default.success=Default relation type successfully updated.
+datasets.api.datasetRelationType.error.create=Something went wrong. Relation type could not be created.
+datasets.api.datasetRelationType.error.create.duplicate=Relation type could not be created because the relation type name or inverse are not unique.
+datasets.api.datasetRelationType.error.create.notNull=Relation type could not be created because required fields are missing.
+datasets.api.datasetRelationType.error.create.superuserOnly=Only superusers can create a new relation type.
+datasets.api.datasetRelationType.error.delete=Something went wrong. Relation type could not be deleted.
+datasets.api.datasetRelationType.error.delete.superuserOnly=Only superusers can delete a relation type.
+datasets.api.datasetRelationType.error.delete.referenced=Relation type could not be deleted because at least one relations of this type still exists.
+datasets.api.datasetRelationType.error.delete.default=The default relation type cannot be deleted. Set another default relation type first.
+datasets.api.datasetRelationType.error.default.superuserOnly=Only superusers can change the default relation type.
+datasets.api.datasetRelationType.error.default.notFound=No default relation type is configured.
+datasets.api.datasetRelationType.error.idRequired=Relation type ID is required.
+datasets.api.datasetRelationType.error.idMustBeNumber=Relation type ID must be a number.
+datasets.api.datasetRelationType.error.notFound=Relation type with id/name {0} not found.
 
 #Dataverses.java
 dataverses.api.update.default.contributor.role.failure.role.not.found=Role {0} not found.
@@ -2989,6 +3019,7 @@ permission.ViewUnpublishedDataset.label=ViewUnpublishedDataset
 permission.DownloadFile.label=DownloadFile
 permission.EditDataverse.label=EditDataverse
 permission.EditDataset.label=EditDataset
+permission.EditDatasetRelations.label=EditDatasetRelations
 permission.ManageDataversePermissions.label=ManageDataversePermissions
 permission.ManageDatasetPermissions.label=ManageDatasetPermissions
 permission.PublishDataverse.label=PublishDataverse
@@ -3010,6 +3041,7 @@ permission.ManageFilePermissions.desc=Manage permissions for a file
 permission.ManageDatasetPermissions.desc=Manage permissions for a dataset
 permission.ManageDataversePermissions.desc=Manage permissions for a dataverse
 permission.EditDataset.desc=Edit a dataset's metadata, license, terms and add/delete files
+permission.EditDatasetRelations.desc=Create, replace, and delete dataset relations
 permission.EditDataverse.desc=Edit a dataverse's metadata, facets, customization, and templates 
 permission.DownloadFile.desc=Download a file
 permission.ViewUnpublishedDataset.desc=View an unpublished dataset and its files
diff --git a/src/main/resources/db/migration/V6.X.0.Y-dataset-relations.sql b/src/main/resources/db/migration/V6.X.0.Y-dataset-relations.sql
new file mode 100644
index 00000000000..2fc8da84873
--- /dev/null
+++ b/src/main/resources/db/migration/V6.X.0.Y-dataset-relations.sql
@@ -0,0 +1,42 @@
+CREATE TABLE IF NOT EXISTS datasetrelationtype (
+                                                   id BIGINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+                                                   name VARCHAR(255) NOT NULL,
+                                                   displayname VARCHAR(255) NOT NULL,
+                                                   description VARCHAR(255),
+                                                   isdefault BOOLEAN NOT NULL DEFAULT FALSE,
+                                                   inverse_id BIGINT,
+                                                   UNIQUE (name),
+                                                   UNIQUE (displayname),
+                                                   UNIQUE (inverse_id),
+                                                   CONSTRAINT fk_datasetrelationtype_inverse_id FOREIGN KEY (inverse_id) REFERENCES datasetrelationtype(id)
+);
+
+CREATE TABLE IF NOT EXISTS datasetrelation (
+                                              id BIGINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+                                              dataset_id BIGINT NOT NULL,
+                                              definitionpoint_id BIGINT NOT NULL,
+                                              relation_source VARCHAR(31),
+                                              relateddataset_id BIGINT,
+                                              relationtype_id BIGINT NOT NULL,
+                                              externalidentifier VARCHAR(512),
+                                              identifierscheme VARCHAR(255),
+                                              datasettype VARCHAR(255),
+                                              CONSTRAINT datasetrelation_internal_unique UNIQUE (dataset_id, relateddataset_id, relationtype_id, definitionpoint_id),
+                                              CONSTRAINT datasetrelation_external_unique UNIQUE (dataset_id, externalidentifier, relationtype_id, definitionpoint_id),
+                                              CONSTRAINT fk_datasetrelation_dataset_id FOREIGN KEY (dataset_id) REFERENCES dvobject(id),
+                                              CONSTRAINT fk_datasetrelation_definitionpoint_id FOREIGN KEY (definitionpoint_id) REFERENCES datasetversion(id),
+                                              CONSTRAINT fk_datasetrelation_relateddataset_id FOREIGN KEY (relateddataset_id) REFERENCES dvobject(id),
+                                              CONSTRAINT fk_datasetrelation_relationtype_id FOREIGN KEY (relationtype_id) REFERENCES datasetrelationtype(id)
+);
+
+CREATE INDEX IF NOT EXISTS index_datasetrelation_dataset ON datasetrelation (dataset_id);
+CREATE INDEX IF NOT EXISTS index_datasetrelation_relateddataset ON datasetrelation (relateddataset_id);
+CREATE INDEX IF NOT EXISTS index_datasetrelation_definitionpoint ON datasetrelation (definitionpoint_id);
+CREATE INDEX IF NOT EXISTS index_datasetrelation_relateddataset_definitionpoint ON datasetrelation (relateddataset_id, definitionpoint_id);
+CREATE UNIQUE INDEX IF NOT EXISTS datasetrelationtype_one_default ON datasetrelationtype (isdefault) WHERE isdefault = TRUE;
+
+-- EditDatasetRelations is permission bit 17 (65536). Existing built-in roles
+-- that can edit datasets should also be able to edit dataset relations.
+UPDATE dataverserole
+SET permissionbits = permissionbits | 65536
+WHERE owner_id IS NULL AND (permissionbits & 64) != 0;
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java
new file mode 100644
index 00000000000..b76fbc3579d
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java
@@ -0,0 +1,281 @@
+package edu.harvard.iq.dataverse.api;
+
+import io.restassured.RestAssured;
+import io.restassured.response.Response;
+import jakarta.json.Json;
+import jakarta.json.JsonObjectBuilder;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static jakarta.ws.rs.core.Response.Status.*;
+import static org.hamcrest.Matchers.*;
+
+/**
+ * @author Vera Clemens (ZB MED)
+ */
+public class DatasetRelationTypesIT {
+
+    private static String apiTokenSuperuser;
+    private static String apiTokenNormalUser;
+
+    @BeforeAll
+    public static void setUpClass() {
+        RestAssured.baseURI = UtilIT.getRestAssuredBaseUri();
+        RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
+
+        Response createSuperuser = UtilIT.createRandomUser();
+        createSuperuser.then().assertThat().statusCode(OK.getStatusCode());
+        String usernameSuperuser = UtilIT.getUsernameFromResponse(createSuperuser);
+        apiTokenSuperuser = UtilIT.getApiTokenFromResponse(createSuperuser);
+        UtilIT.setSuperuserStatus(usernameSuperuser, true).then().assertThat().statusCode(OK.getStatusCode());
+
+        Response createNormalUser = UtilIT.createRandomUser();
+        createNormalUser.then().assertThat().statusCode(OK.getStatusCode());
+        apiTokenNormalUser = UtilIT.getApiTokenFromResponse(createNormalUser);
+    }
+
+    @Test
+    public void testRelationTypeCRUD() {
+        String name = "testRelation" + UtilIT.getRandomString(6);
+        String displayName = "Test Relation " + UtilIT.getRandomString(6);
+        String description = "Test description";
+
+        // Create relation type without inverse
+        JsonObjectBuilder builder = Json.createObjectBuilder()
+                .add("name", name)
+                .add("displayName", displayName)
+                .add("description", description);
+
+        UtilIT.addDatasetRelationType(builder.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.setDefaultDatasetRelationType(name, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.getDefaultDatasetRelationType(apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo(name))
+                .body("data.default", equalTo(true));
+
+        // Get relation type
+        UtilIT.getDatasetRelationType(name, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo(name))
+                .body("data.displayName", equalTo(displayName))
+                .body("data.description", equalTo(description))
+                .body("data.default", equalTo(true));
+
+        String name2 = "testRelation2" + UtilIT.getRandomString(6);
+        String displayName2 = "Test Relation 2 " + UtilIT.getRandomString(6);
+        String description2 = "Test description2";
+
+        // Create relation type which is inverse of itself
+        JsonObjectBuilder builder2 = Json.createObjectBuilder()
+                .add("name", name2)
+                .add("displayName", displayName2)
+                .add("description", description2)
+                .add("inverse", Json.createObjectBuilder().add("name", name2));
+
+        UtilIT.addDatasetRelationType(builder2.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Get relation type
+        UtilIT.getDatasetRelationType(name2, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo(name2))
+                .body("data.displayName", equalTo(displayName2))
+                .body("data.description", equalTo(description2))
+                .body("data.inverse.name", equalTo(name2))
+                .body("data.inverse.displayName", equalTo(displayName2))
+                .body("data.inverse.description", equalTo(description2));
+
+        String name3 = "testRelation3" + UtilIT.getRandomString(6);
+        String displayName3 = "Test Relation 3 " + UtilIT.getRandomString(6);
+        String description3 = "Test description3";
+        String inverseName3 = "testInverseRelation3" + UtilIT.getRandomString(6);
+        String inverseDisplayName3 = "Test Inverse Relation 3 " + UtilIT.getRandomString(6);
+        String inverseDescription3 = "Test inverse description3";
+
+        // Create relation type with an inverse relation type
+        JsonObjectBuilder builder3 = Json.createObjectBuilder()
+                .add("name", name3)
+                .add("displayName", displayName3)
+                .add("description", description3)
+                .add("inverse", Json.createObjectBuilder().add("name", inverseName3)
+                                                                 .add("displayName", inverseDisplayName3)
+                                                                 .add("description", inverseDescription3));
+
+        UtilIT.addDatasetRelationType(builder3.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Get relation types
+        UtilIT.getDatasetRelationType(name3, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo(name3))
+                .body("data.displayName", equalTo(displayName3))
+                .body("data.description", equalTo(description3))
+                .body("data.inverse.name", equalTo(inverseName3))
+                .body("data.inverse.displayName", equalTo(inverseDisplayName3))
+                .body("data.inverse.description", equalTo(inverseDescription3));
+
+        UtilIT.getDatasetRelationType(inverseName3, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo(inverseName3))
+                .body("data.displayName", equalTo(inverseDisplayName3))
+                .body("data.description", equalTo(inverseDescription3))
+                .body("data.inverse.name", equalTo(name3))
+                .body("data.inverse.displayName", equalTo(displayName3))
+                .body("data.inverse.description", equalTo(description3));
+
+        // List all relation types
+        UtilIT.listDatasetRelationTypes(apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", hasItem(name))
+                .body("data.name", hasItem(name2))
+                .body("data.name", hasItem(name3))
+                .body("data.name", hasItem(inverseName3));
+
+        // The default type cannot be deleted.
+        UtilIT.deleteDatasetRelationType(name, apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        // Delete relation types after selecting another default.
+        UtilIT.setDefaultDatasetRelationType(name2, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.deleteDatasetRelationType(name, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.setDefaultDatasetRelationType(name3, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.deleteDatasetRelationType(name2, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.setDefaultDatasetRelationType(inverseName3, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.deleteDatasetRelationType(name3, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.getDefaultDatasetRelationType(apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo(inverseName3))
+                .body("data.default", equalTo(true));
+
+        // Verify deleted
+        UtilIT.getDatasetRelationType(name, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+        UtilIT.getDatasetRelationType(name2, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+        UtilIT.getDatasetRelationType(name3, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+        UtilIT.getDatasetRelationType(inverseName3, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+    }
+
+    @Test
+    public void testCreateRelationTypeValidation() {
+        // Missing name
+        JsonObjectBuilder noName = Json.createObjectBuilder()
+                .add("displayName", "No Name");
+        UtilIT.addDatasetRelationType(noName.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        // Missing displayName
+        JsonObjectBuilder noDisplayName = Json.createObjectBuilder()
+                .add("name", "noDisplayName");
+        UtilIT.addDatasetRelationType(noDisplayName.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+        
+        // Empty name
+        JsonObjectBuilder emptyName = Json.createObjectBuilder()
+                .add("name", "")
+                .add("displayName", "Empty Name");
+        UtilIT.addDatasetRelationType(emptyName.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+    }
+
+    @Test
+    public void testRelationTypePermissions() {
+        String name = "permTest" + UtilIT.getRandomString(6);
+        JsonObjectBuilder builder = Json.createObjectBuilder()
+                .add("name", name)
+                .add("displayName", "Perm Test" + UtilIT.getRandomString(6));
+        String jsonIn = builder.build().toString();
+
+        // Create as normal user fails
+        UtilIT.addDatasetRelationType(jsonIn, apiTokenNormalUser)
+                .then().assertThat().statusCode(FORBIDDEN.getStatusCode());
+
+        // Create as superuser succeeds
+        UtilIT.addDatasetRelationType(jsonIn, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        String defaultName = "permDefault" + UtilIT.getRandomString(6);
+        UtilIT.addDatasetRelationType(Json.createObjectBuilder()
+                        .add("name", defaultName)
+                        .add("displayName", "Perm Default " + UtilIT.getRandomString(6))
+                        .build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.setDefaultDatasetRelationType(name, apiTokenNormalUser)
+                .then().assertThat().statusCode(FORBIDDEN.getStatusCode());
+        UtilIT.setDefaultDatasetRelationType(defaultName, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Delete as normal user fails
+        UtilIT.deleteDatasetRelationType(name, apiTokenNormalUser)
+                .then().assertThat().statusCode(FORBIDDEN.getStatusCode());
+
+        // Delete as superuser succeeds
+        UtilIT.deleteDatasetRelationType(name, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+    }
+
+    @Test
+    public void testDeleteRelationTypeFailureWhenInUse() {
+        String typeName = "inUseTest" + UtilIT.getRandomString(6);
+        JsonObjectBuilder builder = Json.createObjectBuilder()
+                .add("name", typeName)
+                .add("displayName", "In Use Test" + UtilIT.getRandomString(6));
+
+        UtilIT.addDatasetRelationType(builder.build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Create datasets and a relation of this type
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        String relationJson = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", typeName))
+                .build().toString();
+
+        UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Try to delete the relation type while it's in use
+        // Expected behavior: should fail because of existing relations
+        UtilIT.deleteDatasetRelationType(typeName, apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        // Cleanup: remove relation first
+        // Need the relation ID
+        Response listResponse = UtilIT.listDatasetRelations(pidA, apiTokenSuperuser);
+        int relationId = listResponse.jsonPath().getInt("data[0].id");
+        UtilIT.deleteDatasetRelation(pidA, relationId, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        String defaultName = "defaultAfterInUse" + UtilIT.getRandomString(6);
+        UtilIT.addDatasetRelationType(Json.createObjectBuilder()
+                        .add("name", defaultName)
+                        .add("displayName", "Default After In Use " + UtilIT.getRandomString(6))
+                        .build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.setDefaultDatasetRelationType(defaultName, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Now deleting the relation type should work
+        UtilIT.deleteDatasetRelationType(typeName, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java
new file mode 100644
index 00000000000..8275c22226c
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java
@@ -0,0 +1,1306 @@
+package edu.harvard.iq.dataverse.api;
+
+import edu.harvard.iq.dataverse.authorization.DataverseRole;
+import io.restassured.RestAssured;
+import io.restassured.path.json.JsonPath;
+import io.restassured.response.Response;
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonValue;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static jakarta.ws.rs.core.Response.Status.*;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * @author Vera Clemens (ZB MED)
+ */
+public class DatasetRelationsIT {
+
+    private static String apiTokenSuperuser;
+
+    @BeforeAll
+    public static void setUpClass() {
+        RestAssured.baseURI = UtilIT.getRestAssuredBaseUri();
+
+        RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
+
+        Response createUser = UtilIT.createRandomUser();
+        createUser.then().assertThat().statusCode(OK.getStatusCode());
+        String usernameSuperuser = UtilIT.getUsernameFromResponse(createUser);
+        apiTokenSuperuser = UtilIT.getApiTokenFromResponse(createUser);
+        UtilIT.setSuperuserStatus(usernameSuperuser, true).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Ensure relation types exist
+        String relationTypeJson = Json.createObjectBuilder()
+                .add("name", "isRelatedTo")
+                .add("displayName", "Is related to")
+                .add("inverse", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                .build().toString();
+        UtilIT.addDatasetRelationType(relationTypeJson, apiTokenSuperuser);
+        
+        String relationTypeJson2 = Json.createObjectBuilder()
+                .add("name", "isSupplementTo")
+                .add("displayName", "Is supplement to")
+                .add("inverse", Json.createObjectBuilder().add("name", "isSupplementedBy").add("displayName", "Is supplemented by"))
+                .build().toString();
+        UtilIT.addDatasetRelationType(relationTypeJson2, apiTokenSuperuser);
+
+        String relationTypeJson3 = Json.createObjectBuilder()
+                .add("name", "isCitedBy")
+                .add("displayName", "Is cited by")
+                .add("inverse", Json.createObjectBuilder().add("name", "cites").add("displayName", "Cites"))
+                .build().toString();
+        UtilIT.addDatasetRelationType(relationTypeJson3, apiTokenSuperuser);
+
+        String relationTypeWithoutInverseJson = Json.createObjectBuilder()
+                .add("name", "isDerivedFromWithoutInverse")
+                .add("displayName", "Is derived from without inverse")
+                .build().toString();
+        UtilIT.addDatasetRelationType(relationTypeWithoutInverseJson, apiTokenSuperuser);
+
+        UtilIT.setDefaultDatasetRelationType("isRelatedTo", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+    }
+
+    @Test
+    public void testListDatasetRelationsFilteringByRelationTypeAndVersion() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Dataset A - will have relations in multiple versions
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Dataset B
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // Dataset C
+        Response createDatasetC = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidC = UtilIT.getDatasetPersistentIdFromResponse(createDatasetC);
+
+        // Version 1.0 of Dataset A:
+        // Relation 1: A -> B (isRelatedTo)
+        JsonArray relationsV1 = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relationsV1.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Version 2.0 of Dataset A:
+        // Relation 1: A -> B (isRelatedTo) - kept from V1
+        // Relation 2: A -> B (isSupplementTo)
+        // Relation 2: A -> C (isSupplementTo)
+        JsonArray relationsV2 = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidC)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
+                .build();
+        // This will create a draft for v2.0
+        UtilIT.replaceDatasetRelations(pidA, relationsV2.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        // Publish v2.0
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Current state:
+        // V1.0: 1 relation (isRelatedTo)
+        // v2.0: 3 relations (1x isRelatedTo, 2x isSupplementTo)
+
+        // 1. Filter by Version AND Type (V1.0, isRelatedTo) -> Expect 1
+        UtilIT.listDatasetRelations(pidA, "1.0", List.of("isRelatedTo"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1));
+
+        // 2. Filter by Version AND Type (V1.0, isSupplementTo) -> Expect 0
+        UtilIT.listDatasetRelations(pidA, "1.0", List.of("isSupplementTo"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0));
+
+        // 3. Filter by Version AND Type (v2.0, isSupplementTo) -> Expect 2
+        UtilIT.listDatasetRelations(pidA, "2.0", List.of("isSupplementTo"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2));
+
+        // 4. Filter by Version only (V1.0) -> Expect 1
+        UtilIT.listDatasetRelations(pidA, "1.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1));
+
+        // 5. Filter by Version only (v2.0) -> Expect 3
+        UtilIT.listDatasetRelations(pidA, "2.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(3));
+
+        // 6. Filter by Type only (isSupplementTo) -> Expect 2 (from latest published v2.0)
+        UtilIT.listDatasetRelations(pidA, null, List.of("isSupplementTo"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2));
+
+        // 7. Filter by Type only (isRelatedTo) -> Expect 1 (from latest published v2.0)
+        UtilIT.listDatasetRelations(pidA, null, List.of("isRelatedTo"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1));
+
+        // 8. Filter by Types only (isRelatedTo, isSupplementTo) -> Expect 3 (from latest published v2.0)
+        UtilIT.listDatasetRelations(pidA, null, Arrays.asList("isRelatedTo", "isSupplementTo"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(3));
+
+        // A superuser can replace relations on a selected published version
+        UtilIT.replaceDatasetRelations(pidA, "[]", "1.0", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.listDatasetRelations(pidA, "1.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0));
+
+        UtilIT.listDatasetRelations(pidA, "2.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(3));
+
+        // 9. No filters (latest version) -> Expect 3
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(3));
+    }
+
+    @Test
+    public void testListDatasetRelationsFilteringByDatasetType() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Ensure 'software' type exists in the system
+        Response getDatasetType = UtilIT.getDatasetType("software");
+        String typeFound = JsonPath.from(getDatasetType.getBody().asString()).getString("data.name");
+        if (!("software".equals(typeFound))) {
+            JsonObject softwareTypeJson = Json.createObjectBuilder()
+                    .add("name", "software")
+                    .add("displayName", "Software")
+                    .add("description", "Software Dataset Type")
+                    .build();
+            UtilIT.addDatasetType(softwareTypeJson.toString(), apiTokenSuperuser);
+        }
+
+        // We need to ensure 'software' type is allowed in this collection
+        Response setAllowed = UtilIT.setCollectionAttribute(dataverseAlias, "allowedDatasetTypes", "dataset,software", apiTokenSuperuser);
+        setAllowed.then().assertThat().statusCode(OK.getStatusCode());
+
+        // Dataset A (Source) - type 'dataset' (default)
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Dataset B (Target 1) - type 'dataset' (default)
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // Dataset C (Target 2) - type 'software'
+        String softwareJson = UtilIT.getDatasetJson("doc/sphinx-guides/source/_static/api/dataset-create-software.json");
+        Response createDatasetC = UtilIT.createDataset(dataverseAlias, softwareJson, apiTokenSuperuser);
+        createDatasetC.then().assertThat().statusCode(201);
+        String pidC = UtilIT.getDatasetPersistentIdFromResponse(createDatasetC);
+
+        // Create relations: A -> B (isRelatedTo), A -> C (isRelatedTo), A -> External (isRelatedTo)
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidC)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder()
+                        .add("externalIdentifier", "doi:10.1234/external")
+                        .add("identifierScheme", "DOI")
+                        .add("datasetType", "Software")
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                        .add("relationSource", "external"))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // No type filter -> Expect 3
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(3));
+
+        // Filter by datasetType=dataset -> Expect 1 (Dataset B)
+        UtilIT.listDatasetRelations(pidA, null, null, Arrays.asList("dataset"), null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidB));
+
+        // Filter by datasetType=software -> Expect 1 (Dataset C)
+        UtilIT.listDatasetRelations(pidA, null, null, Arrays.asList("software"), null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidC));
+
+        // Filter by both -> Expect 2 (B and C)
+        UtilIT.listDatasetRelations(pidA, null, null, Arrays.asList("dataset", "software"), null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2))
+                .body("data.items.relatedDatasetPid", hasItems(pidB, pidC));
+
+        // Filter by a non-existent type -> Expect 0
+        UtilIT.listDatasetRelations(pidA, null, null, Arrays.asList("workflow"), null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0));
+
+        // Expect correct dataset-type facets
+        UtilIT.listDatasetRelations(pidA, null, null, null, null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.facets.datasetType", hasSize(2))
+                .body("data.facets.datasetType[0].name", equalTo("dataset"))
+                .body("data.facets.datasetType[0].count", equalTo(1))
+                .body("data.facets.datasetType[1].name", equalTo("software"))
+                .body("data.facets.datasetType[1].count", equalTo(1));
+
+        // Expect correct relation-type facets (applying the active dataset-type filter)
+        UtilIT.listDatasetRelations(pidA, null, null, List.of("software"), null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.facets.relationType", hasSize(1))
+                .body("data.facets.relationType[0].name", equalTo("isRelatedTo"))
+                .body("data.facets.relationType[0].count", equalTo(1));
+    }
+
+    @Test
+    public void testListDatasetRelationsFilteringBySource() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Dataset A
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Dataset B
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // Create 1 internal and 1 external relation
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder()
+                        .add("externalIdentifier", "https://example.org/1")
+                        .add("identifierScheme", "URL")
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // No filter -> Expect 2
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2));
+
+        // Filter by source=internal -> Expect 1
+        UtilIT.listDatasetRelations(pidA, null, null, null, List.of("internal"), null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidB));
+
+        // Filter by source=internal and type=dataset -> Expect 1
+        UtilIT.listDatasetRelations(pidA, null, null, List.of("dataset"), List.of("internal"), null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidB));
+
+        // Filter by source=external -> Expect 1
+        UtilIT.listDatasetRelations(pidA, null, null, null, List.of("external"), null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].externalIdentifier", equalTo("https://example.org/1"));
+
+        // Filter by both -> Expect 2
+        UtilIT.listDatasetRelations(pidA, null, null, null, Arrays.asList("internal", "external"), null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2));
+    }
+
+    @Test
+    public void testListDatasetRelationsOrdering() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Create Dataset A
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Create Dataset B
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // Create Dataset C
+        Response createDatasetC = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidC = UtilIT.getDatasetPersistentIdFromResponse(createDatasetC);
+
+        // Define relation B -> A (defined on B)
+        JsonArray relationsB = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidA)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidB, relationsB.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Define relation A -> C (defined on A)
+        JsonArray relationsA = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidC)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relationsA.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // List relations for A
+        // Expecting:
+        // 1. A -> C (defined on A)
+        // 2. B -> A (defined on B)
+
+        Response listResponse = UtilIT.listDatasetRelations(pidA, apiTokenSuperuser);
+        listResponse.then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.items", hasSize(2));
+
+        // We want relations defined ON dataset A to come first:
+        // Relation A -> C is defined on A (definitionPointPid should be pidA)
+        // Relation B -> A is defined on B (definitionPointPid should be pidB)
+
+        List<String> definitionPointPids = listResponse.jsonPath().getList("data.items.definitionPointPid");
+        assertEquals(pidA, definitionPointPids.get(0));
+        assertEquals(pidB, definitionPointPids.get(1));
+    }
+
+    @Test
+    public void testListDatasetRelationDeduplication() {
+        // Create Dataset A
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Create Dataset B
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+        Integer datasetBId = UtilIT.getDatasetIdFromResponse(createDatasetB);
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        assertTrue(UtilIT.sleepForSearch("id:dataset_" + datasetBId + " AND relatedDatasetCount:0", apiTokenSuperuser, "", 1, UtilIT.GENERAL_LONG_DURATION));
+        UtilIT.search("id:dataset_" + datasetBId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.items[0].relatedDatasetCount", equalTo(0));
+
+        // Define relation A (draft) -> B
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Publish A v1.0
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Publishing A makes its internal relation visible to B, so B's Solr count must have been reindexed
+        assertTrue(UtilIT.sleepForSearch("id:dataset_" + datasetBId + " AND relatedDatasetCount:1", apiTokenSuperuser, "", 1, UtilIT.GENERAL_LONG_DURATION));
+        UtilIT.search("id:dataset_" + datasetBId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.items[0].relatedDatasetCount", equalTo(1));
+
+        // Define the SAME relation in inverse direction: B (draft) -> A
+        JsonArray relationsInverse = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidA)
+                        .add("relationType", Json.createObjectBuilder().add("name", "cites")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidB, relationsInverse.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Publish B v1.0
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Create A v2 (draft) and add one more relation
+        // (The existing relation from A v1 still exists)
+        String externalUrl = "https://example.org/dataset/12345";
+        JsonObject relationNew = Json.createObjectBuilder()
+                .add("externalIdentifier", externalUrl)
+                .add("identifierScheme", "URL")
+                .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                .build();
+        UtilIT.addDatasetRelation(pidA, relationNew.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // The relation "A is cited by B" is now present 3 times: in A v1, B v1, A draft
+        // Plus the additional relation in A draft: "A is related to https://example.org/dataset/12345"
+
+        // Verify only those two relations are listed for A (draft) (no duplicates)
+        UtilIT.listDatasetRelations(pidA, ":draft", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2))
+                .body("data.items", hasSize(2))
+                .body("data.items.relatedDatasetPid", hasItem(pidB))
+                .body("data.items.externalIdentifier", hasItem(externalUrl));
+
+        // Verify relation-type facets
+        UtilIT.listDatasetRelations(pidA, ":draft", null, null, null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.facets.relationType", hasSize(2))
+                .body("data.facets.relationType[0].name", equalTo("isCitedBy"))
+                .body("data.facets.relationType[0].count", equalTo(1))
+                .body("data.facets.relationType[1].name", equalTo("isRelatedTo"))
+                .body("data.facets.relationType[1].count", equalTo(1));
+    }
+
+    @Test
+    public void testListDatasetRelationsVersionIsolation() {
+        // Create Dataset A, published v1.0
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Create Dataset B, draft version
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // Add relation from Dataset B (draft) to Dataset A (v1.0) at dataset B (draft)
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidA)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+
+        UtilIT.replaceDatasetRelations(pidB, relations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify relation is listed when requesting relations for Dataset B (draft)
+        UtilIT.listDatasetRelations(pidB, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidA))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Verify relation is not listed when requesting relations for Dataset A (v1)
+        // since Dataset B, where the relation was defined, is still in Draft status
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0))
+                .body("data.items", hasSize(0));
+
+        // Publish Dataset B (=> v1.0)
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify relation is now listed when requesting relations for Dataset A
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidB))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Verify relation is listed when requesting relations for Dataset B v1.0
+        UtilIT.listDatasetRelations(pidB, "1.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidA))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Remove the relation in new version of Dataset B (draft)
+        UtilIT.replaceDatasetRelations(pidB, "[]", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify relation is still listed when requesting relations for Dataset A
+        // Because Dataset B is still in draft mode
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidB))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Verify relation is still listed when requesting relations for Dataset B without a token
+        // Because without a token, users cannot see Dataset B's draft
+        UtilIT.listDatasetRelations(pidB)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidA))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Verify relation is not listed when requesting relations for Dataset B's draft specifically
+        UtilIT.listDatasetRelations(pidB, ":draft", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0))
+                .body("data.items", hasSize(0));
+
+        // Publish Dataset B (=> v2.0)
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify relation is NO LONGER listed when requesting relations for Dataset A
+        // Because Dataset B is now at v2 and v2 has no relation
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0))
+                .body("data.items", hasSize(0));
+
+        // Verify relation is STILL listed when requesting relations for Dataset B v1 specifically
+        UtilIT.listDatasetRelations(pidB, "1.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidA))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Verify relation is NOT listed when requesting relations for Dataset B v2
+        UtilIT.listDatasetRelations(pidB, "2.0", null, null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0))
+                .body("data.items", hasSize(0));
+
+        // Verify relation is NOT listed when requesting relations for Dataset B
+        UtilIT.listDatasetRelations(pidB, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0))
+                .body("data.items", hasSize(0));
+    }
+
+    @Test
+    public void testListExternalDatasetRelations() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Add external relation to Dataset A (draft)
+        String externalUrl = "https://example.org/dataset/12345";
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("externalIdentifier", externalUrl)
+                        .add("identifierScheme", "URL")
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify external relation is listed
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].externalIdentifier", equalTo(externalUrl))
+                .body("data.items[0].identifierScheme", equalTo("URL"))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Add external relation with datasetType
+        String externalUrlWithDocType = "https://example.org/dataset/67890";
+        JsonArray relationsWithDocType = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("externalIdentifier", externalUrlWithDocType)
+                        .add("identifierScheme", "URL")
+                        .add("relatedDatasetType", Json.createObjectBuilder().add("displayName", "Document"))
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+
+        UtilIT.replaceDatasetRelations(pidA, relationsWithDocType.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify external relation with datasetType is listed
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items", hasSize(1))
+                .body("data.items[0].externalIdentifier", equalTo(externalUrlWithDocType))
+                .body("data.items[0].relatedDatasetType.displayName", equalTo("Document"));
+
+        // An external free-text dataset type is included in the dataset-type facet.
+        UtilIT.listDatasetRelations(pidA, null, null, null, null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.facets.datasetType", hasSize(1))
+                .body("data.facets.datasetType[0].displayName", equalTo("Document"))
+                .body("data.facets.datasetType[0].count", equalTo(1));
+
+        // The free-text facet value can also be used with the datasetType filter.
+        UtilIT.listDatasetRelations(pidA, null, null, List.of("Document"), null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].externalIdentifier", equalTo(externalUrlWithDocType));
+
+        // Add both internal and external relations
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        JsonArray mixedRelations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder()
+                        .add("externalIdentifier", "doi:10.1234/5678")
+                        .add("identifierScheme", "DOI")
+                        .add("relatedDatasetType", Json.createObjectBuilder().add("displayName", "Dataset"))
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+
+        UtilIT.replaceDatasetRelations(pidA, mixedRelations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2))
+                .body("data.items", hasSize(2))
+                .body("data.items[1].relatedDatasetPid", equalTo(pidB))
+                .body("data.items[1].relatedDatasetType.name", equalTo("dataset"))
+                .body("data.items[1].relatedDatasetType.displayName", equalTo("Dataset"))
+                .body("data.items[0].externalIdentifier", equalTo("doi:10.1234/5678"))
+                .body("data.items[0].identifierScheme", equalTo("DOI"))
+                .body("data.items[0].relatedDatasetType.name", equalTo(null))
+                .body("data.items[0].relatedDatasetType.displayName", equalTo("Dataset"));
+
+        // An external type matching an internal type's display name shares its facet value
+        UtilIT.listDatasetRelations(pidA, null, null, null, null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.facets.datasetType", hasSize(1))
+                .body("data.facets.datasetType[0].name", equalTo("dataset"))
+                .body("data.facets.datasetType[0].displayName", equalTo("Dataset"))
+                .body("data.facets.datasetType[0].count", equalTo(2));
+
+        UtilIT.listDatasetRelations(pidA, null, null, List.of("dataset"), null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(2));
+    }
+
+    @Test
+    public void testDestroyDatasetRemovesIncomingRelations() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+        int idB = UtilIT.getDatasetIdFromResponse(createDatasetB);
+
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1));
+
+        UtilIT.destroyDataset(idB, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0))
+                .body("data.items", hasSize(0));
+    }
+
+    @Test
+    public void testInternalRelationsWithoutInverseType() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
+
+        // Create relation A -> B using a relation type that has no inverse
+        JsonObject relation = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "isDerivedFromWithoutInverse"))
+                .build();
+        Response createRelation = UtilIT.addDatasetRelation(pidA, relation.toString(), apiTokenSuperuser);
+        createRelation.then().assertThat().statusCode(OK.getStatusCode());
+
+        int relationId = createRelation.jsonPath().getInt("data.id");
+
+        // Retrieving the relation for dataset A lists the relation type
+        UtilIT.getDatasetRelation(pidA, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.datasetPid", equalTo(pidA))
+                .body("data.relatedDatasetPid", equalTo(pidB))
+                .body("data.relationType.name", equalTo("isDerivedFromWithoutInverse"));
+
+        // Retrieving the relation for dataset B lists no relation type (because the type has no inverse)
+        UtilIT.getDatasetRelation(pidB, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.datasetPid", equalTo(pidB))
+                .body("data.relatedDatasetPid", equalTo(pidA))
+                .body("data.relationType.name", equalTo(null));
+
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.listDatasetRelations(pidB, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].datasetPid", equalTo(pidB))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidA))
+                .body("data.items[0].relationType.name", equalTo(null));
+
+        UtilIT.listDatasetRelations(pidB, null, List.of("isDerivedFromWithoutInverse"), null, null, null, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(0));
+    }
+
+    @Test
+    public void testGetDatasetRelationCounts() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Create main Dataset A
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        // Create other datasets to relate to
+        String[] pids = new String[8];
+        for (int i = 0; i < 8; i++) {
+            Response createDataset = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+            pids[i] = UtilIT.getDatasetPersistentIdFromResponse(createDataset);
+        }
+
+        // Setup relations:
+        // isCitedBy: 3 relations
+        // isRelatedTo: 3 relations (including one that omits its type)
+        // isSupplementTo: 2 relations
+        // (Alphabetical: isCitedBy < isRelatedTo < isSupplementTo)
+        // Expected order:
+        // 1. isCitedBy (count: 3)
+        // 2. isRelatedTo (count: 3)
+        // 3. isSupplementTo (count: 2)
+
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[0]).add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[1]).add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[2]).add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[3]).add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[4]).add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[5]).add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[6]).add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[7]))
+                .build();
+
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Check facets and sorting
+        UtilIT.listDatasetRelations(pidA, null, null, null, null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.facets.relationType", hasSize(3))
+                // 1st: isCitedBy (count 3)
+                .body("data.facets.relationType[0].name", equalTo("isCitedBy"))
+                .body("data.facets.relationType[0].count", equalTo(3))
+                // 2nd: isRelatedTo (count 3)
+                .body("data.facets.relationType[1].name", equalTo("isRelatedTo"))
+                .body("data.facets.relationType[1].count", equalTo(3))
+                // 3rd: isSupplementTo (count 2)
+                .body("data.facets.relationType[2].name", equalTo("isSupplementTo"))
+                .body("data.facets.relationType[2].count", equalTo(2))
+                .body("data.facets.datasetType", hasSize(1))
+                .body("data.facets.datasetType[0].name", equalTo("dataset"))
+                .body("data.facets.datasetType[0].count", equalTo(8));
+
+        // The dataset-type facet applies the active relation-type filter
+        UtilIT.listDatasetRelations(pidA, null, List.of("isCitedBy"), null, null, null, null, apiTokenSuperuser, true)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(3))
+                .body("data.facets.datasetType", hasSize(1))
+                .body("data.facets.datasetType[0].name", equalTo("dataset"))
+                .body("data.facets.datasetType[0].count", equalTo(3));
+
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(8));
+    }
+
+    @Test
+    public void testDatasetRelationCRUD() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+        Integer datasetBId = UtilIT.getDatasetIdFromResponse(createDatasetB);
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // POST /api/datasets/{identifier}/relations
+        String relationJson = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .build().toString();
+
+        Response postResponse = UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser);
+        postResponse.then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.id", notNullValue());
+
+        int relationId = postResponse.jsonPath().getInt("data.id");
+
+        // GET /api/datasets/{identifier}/relations/{id}
+        // GET relation for dataset A -> should be isSupplementTo
+        UtilIT.getDatasetRelation(pidA, relationId, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.id", equalTo(relationId))
+                .body("data.relatedDatasetPid", equalTo(pidB))
+                .body("data.relationType.name", equalTo("isSupplementTo"));
+
+        // GET relation for dataset B -> should be isSupplementedBy (inverted)
+        UtilIT.getDatasetRelation(pidB, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relationType.name", equalTo("isSupplementedBy"));
+
+        // POST /api/datasets/{identifier}/relations
+        relationJson = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .build().toString();
+
+        postResponse = UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser);
+        postResponse.then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.id", notNullValue());
+
+        relationId = postResponse.jsonPath().getInt("data.id");
+
+        // GET /api/datasets/{identifier}/relations/{id}
+        // GET relation for dataset A -> should use the default type
+        UtilIT.getDatasetRelation(pidA, relationId, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.id", equalTo(relationId))
+                .body("data.relatedDatasetPid", equalTo(pidB))
+                .body("data.relationType.name", equalTo("isRelatedTo"));
+
+        // GET relation for dataset B -> should use the default type's inverse
+        UtilIT.getDatasetRelation(pidB, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relationType.name", equalTo("isRelatedTo"));
+
+        // DELETE /api/datasets/{identifier}/relations/{id}
+        UtilIT.deleteDatasetRelation(pidA, relationId, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Verify GET after DELETE is 404
+        UtilIT.getDatasetRelation(pidA, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+    }
+
+    @Test
+    public void testDatasetRelationCRUDErrorPaths() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // GET or DELETE on non-existent ID should be 404
+        UtilIT.getDatasetRelation(pidA, 999999, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        UtilIT.deleteDatasetRelation(pidA, 999999, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        // First create a relation
+        String relationJson = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .build().toString();
+
+        long relationId = UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser)
+                .then().extract().jsonPath().getInt("data.id");
+
+        // Try to create relation with non-existent relation type
+        // Should be 400
+        String invalidRelationJson = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "iDontExist"))
+                .build().toString();
+
+        UtilIT.addDatasetRelation(pidA, invalidRelationJson.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        // Create a third dataset C
+        Response createDatasetC = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidC = UtilIT.getDatasetPersistentIdFromResponse(createDatasetC);
+
+        // Try to GET relation with pidC (which is not involved in the relation)
+        // Should be 404
+        UtilIT.getDatasetRelation(pidC, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        // Try to add the already existing relation to B again
+        // Should count as a duplicate and therefore be 400
+        JsonObject dupRelation = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .build();
+
+        UtilIT.addDatasetRelation(pidA, dupRelation.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        // Try to DELETE relation with pidC
+        // Should be 404
+        UtilIT.deleteDatasetRelation(pidC, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        // Try to DELETE relation with pidB
+        // Should be 404
+        UtilIT.deleteDatasetRelation(pidB, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        // Try to DELETE relation with pidA
+        // Should work as the relation was defined on pidA
+        UtilIT.getDatasetRelation(pidB, relationId, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+    }
+
+    @Test
+    public void testDatasetRelationCRUDAuthErrorPaths() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        Response createDatasetA = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(createDatasetA);
+        Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
+
+        // Create a normal user
+        Response createUser = UtilIT.createRandomUser();
+        String apiTokenUser = UtilIT.getApiTokenFromResponse(createUser);
+
+        // Without edit rights on the dataset, post and delete should fail
+        String relationJson = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .build().toString();
+
+        UtilIT.addDatasetRelation(pidA, relationJson, apiTokenUser)
+                .then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Create relation as superuser
+        long relationId = UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser)
+                .then().extract().jsonPath().getInt("data.id");
+
+        // Try to delete as normal user
+        UtilIT.deleteDatasetRelation(pidA, relationId, apiTokenUser)
+                .then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // If not authenticated and the relation isn't published, get should fail
+        UtilIT.getDatasetRelation(pidA, relationId, null)
+                .then().assertThat().statusCode(FORBIDDEN.getStatusCode());
+
+        // Even with a token, if user has no view rights on unpublished dataset, it should fail
+        UtilIT.getDatasetRelation(pidA, relationId, apiTokenUser)
+                .then().assertThat().statusCode(FORBIDDEN.getStatusCode());
+
+        // Publish dataset A and B
+        UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Normal users cannot delete relations defined on a released version
+        UtilIT.deleteDatasetRelation(pidA, relationId, apiTokenUser)
+                .then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // After publication, GET should work even without token
+        UtilIT.getDatasetRelation(pidA, relationId, null)
+                .then().assertThat().statusCode(OK.getStatusCode());
+    }
+
+    @Test
+    public void testReplaceDatasetRelationsErrorPaths() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
+
+        JsonObject typedRelation = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, Json.createArrayBuilder().add(typedRelation).build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        JsonObject untypedRelation = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .build();
+        JsonArray typedThenUntyped = Json.createArrayBuilder()
+                .add(typedRelation)
+                .add(untypedRelation)
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, typedThenUntyped.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        JsonArray untypedThenTyped = Json.createArrayBuilder()
+                .add(untypedRelation)
+                .add(typedRelation)
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, untypedThenTyped.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        JsonArray invalidRelatedDataset = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder().add("relatedDatasetPid", "doi:10.5072/FK2/DOESNOTEXIST"))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, invalidRelatedDataset.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        JsonObject invalidRelationType = Json.createObjectBuilder()
+                .add("relatedDatasetPid", pidB)
+                .add("relationType", Json.createObjectBuilder().add("name", "iDontExist"))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, Json.createArrayBuilder().add(invalidRelationType).build().toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("totalCount", equalTo(1))
+                .body("data.items[0].relatedDatasetPid", equalTo(pidB))
+                .body("data.items[0].relationType.name", equalTo("isRelatedTo"));
+    }
+
+    @Test
+    public void testDatasetRelationsViaVersionApis() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        // Create dataset with relations via POST api/dataverses/%s/datasets
+        String externalUrl1 = "https://example.org/dataset/1";
+        JsonObject datasetData = Json.createObjectBuilder()
+                .add("datasetVersion", Json.createObjectBuilder()
+                        .add("license", Json.createObjectBuilder()
+                                .add("name", "CC0 1.0")
+                                .add("uri", "http://creativecommons.org/publicdomain/zero/1.0"))
+                        .add("metadataBlocks", Json.createObjectBuilder()
+                                .add("citation", Json.createObjectBuilder()
+                                        .add("fields", Json.createArrayBuilder()
+                                                .add(Json.createObjectBuilder()
+                                                        .add("typeName", "title")
+                                                        .add("multiple", false)
+                                                        .add("typeClass", "primitive")
+                                                        .add("value", "Dataset with Relations"))
+                                                .add(Json.createObjectBuilder()
+                                                        .add("typeName", "author")
+                                                        .add("multiple", true)
+                                                        .add("typeClass", "compound")
+                                                        .add("value", Json.createArrayBuilder()
+                                                                .add(Json.createObjectBuilder()
+                                                                        .add("authorName", Json.createObjectBuilder()
+                                                                                .add("typeName", "authorName")
+                                                                                .add("multiple", false)
+                                                                                .add("typeClass", "primitive")
+                                                                                .add("value", "Lastname, Firstname")))))
+                                                .add(Json.createObjectBuilder()
+                                                        .add("typeName", "datasetContact")
+                                                        .add("multiple", true)
+                                                        .add("typeClass", "compound")
+                                                        .add("value", Json.createArrayBuilder()
+                                                                .add(Json.createObjectBuilder()
+                                                                        .add("datasetContactEmail", Json.createObjectBuilder()
+                                                                                .add("typeName", "datasetContactEmail")
+                                                                                .add("multiple", false)
+                                                                                .add("typeClass", "primitive")
+                                                                                .add("value", "test@example.edu")))))
+                                                .add(Json.createObjectBuilder()
+                                                        .add("typeName", "dsDescription")
+                                                        .add("multiple", true)
+                                                        .add("typeClass", "compound")
+                                                        .add("value", Json.createArrayBuilder()
+                                                                .add(Json.createObjectBuilder()
+                                                                        .add("dsDescriptionValue", Json.createObjectBuilder()
+                                                                                .add("typeName", "dsDescriptionValue")
+                                                                                .add("multiple", false)
+                                                                                .add("typeClass", "primitive")
+                                                                                .add("value", "Description text")))))
+                                                .add(Json.createObjectBuilder()
+                                                        .add("typeName", "subject")
+                                                        .add("multiple", true)
+                                                        .add("typeClass", "controlledVocabulary")
+                                                        .add("value", Json.createArrayBuilder().add("Agricultural Sciences"))))))
+                        .add("relations", Json.createArrayBuilder()
+                                .add(Json.createObjectBuilder()
+                                        .add("externalIdentifier", externalUrl1)
+                                        .add("identifierScheme", "URL")
+                                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))))
+                .build();
+
+        Response createDataset = UtilIT.createDataset(dataverseAlias, datasetData.toString(), apiTokenSuperuser);
+        createDataset.then().assertThat().statusCode(CREATED.getStatusCode());
+        String pid = UtilIT.getDatasetPersistentIdFromResponse(createDataset);
+
+        // Read dataset and verify relations are present via GET api/datasets/:persistentId/versions/:draft
+        UtilIT.getDatasetVersion(pid, ":draft", apiTokenSuperuser, false, false, false, false)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relations", hasSize(1))
+                .body("data.relations[0].externalIdentifier", equalTo(externalUrl1))
+                .body("data.relations[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Native JSON imports use the same relation entity parsing as dataset creation
+        String importedPid = "doi:10.5072/FK2/" + UtilIT.getRandomString(6);
+        Response importedDataset = UtilIT.importDatasetNativeJson(apiTokenSuperuser, dataverseAlias,
+                datasetData.toString(), importedPid, "no");
+        importedDataset.then().assertThat().statusCode(CREATED.getStatusCode());
+        UtilIT.getDatasetVersion(importedPid, ":draft", apiTokenSuperuser, false, false, false, false)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relations", hasSize(1))
+                .body("data.relations[0].externalIdentifier", equalTo(externalUrl1))
+                .body("data.relations[0].relationType.name", equalTo("isRelatedTo"));
+
+        // Update dataset with NEW relations via PUT api/datasets/:persistentId/versions/:draft
+        String externalUrl2 = "https://example.org/dataset/2";
+
+        // Reuse the existing data and replace relations
+        JsonObject updatedVersionData = Json.createObjectBuilder(datasetData.getJsonObject("datasetVersion"))
+                .add("relations", Json.createArrayBuilder()
+                        .add(Json.createObjectBuilder()
+                                .add("externalIdentifier", externalUrl2)
+                                .add("identifierScheme", "URL")
+                                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))))
+                .build();
+
+        UtilIT.updateDatasetMetadataViaNative(pid, updatedVersionData, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Replacing a draft with the same relations again must not create duplicates
+        UtilIT.updateDatasetMetadataViaNative(pid, updatedVersionData, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Try to upload invalid relations
+        // Should be 400
+        JsonObject unknownRelationTypeVersion = Json.createObjectBuilder(updatedVersionData)
+                .add("relations", Json.createArrayBuilder()
+                        .add(Json.createObjectBuilder()
+                                .add("externalIdentifier", externalUrl2)
+                                .add("identifierScheme", "URL")
+                                .add("relationType", Json.createObjectBuilder().add("name", "unknownRelationType"))))
+                .build();
+        UtilIT.updateDatasetMetadataViaNative(pid, unknownRelationTypeVersion, apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        JsonObject unknownRelatedDatasetVersion = Json.createObjectBuilder(updatedVersionData)
+                .add("relations", Json.createArrayBuilder()
+                        .add(Json.createObjectBuilder()
+                                .add("relatedDatasetPid", "doi:10.5072/FK2/DOESNOTEXIST")))
+                .build();
+
+        // Change metadata in the same request as the invalid relation
+        // The entire update should roll back
+        JsonObject citation = updatedVersionData.getJsonObject("metadataBlocks").getJsonObject("citation");
+        jakarta.json.JsonArrayBuilder changedFields = Json.createArrayBuilder();
+        for (JsonValue fieldValue : citation.getJsonArray("fields")) {
+            JsonObject field = (JsonObject) fieldValue;
+            if ("title".equals(field.getString("typeName"))) {
+                changedFields.add(Json.createObjectBuilder(field).add("value", "This title must not persist"));
+            } else {
+                changedFields.add(field);
+            }
+        }
+        JsonObject changedMetadataBlocks = Json.createObjectBuilder(updatedVersionData.getJsonObject("metadataBlocks"))
+                .add("citation", Json.createObjectBuilder(citation).add("fields", changedFields))
+                .build();
+        JsonObject invalidRelationAndMetadata = Json.createObjectBuilder(unknownRelatedDatasetVersion)
+                .add("metadataBlocks", changedMetadataBlocks)
+                .build();
+        UtilIT.updateDatasetMetadataViaNative(pid, invalidRelationAndMetadata, apiTokenSuperuser)
+                .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
+
+        // Read again and verify relations are updated
+        UtilIT.getDatasetVersion(pid, ":draft", apiTokenSuperuser, false, false, false, false)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relations", hasSize(1))
+                .body("data.relations[0].externalIdentifier", equalTo(externalUrl2))
+                .body("data.metadataBlocks.citation.fields.find { it.typeName == 'title' }.value", equalTo("Dataset with Relations"))
+                .body("data.relations[0].relationType.name", equalTo("isSupplementTo"));
+
+        UtilIT.publishDatasetViaNativeApi(pid, "major", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        JsonObject versionWithoutRelations = Json.createObjectBuilder(updatedVersionData)
+                .remove("relations")
+                .build();
+        UtilIT.updateDatasetMetadataViaNative(pid, versionWithoutRelations, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+
+        // Omitting relations while creating a new draft preserves those from the prior release
+        UtilIT.getDatasetVersion(pid, ":draft", apiTokenSuperuser, false, false, false, false)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relations", hasSize(1))
+                .body("data.relations[0].externalIdentifier", equalTo(externalUrl2))
+                .body("data.relations[0].relationType.name", equalTo("isSupplementTo"));
+
+        // Harvestable native JSON exports include relations
+        UtilIT.exportDataset(pid, "dataverse_json", true, null, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("datasetVersion.relations", hasSize(1))
+                .body("datasetVersion.relations[0].externalIdentifier", equalTo(externalUrl2))
+                .body("datasetVersion.relations[0].relationType.name", equalTo("isSupplementTo"));
+    }
+
+    @Test
+    public void testVersionSummariesIncludeRelationChanges() {
+        String dataverseAlias = UtilIT.createRandomCollectionGetAlias(apiTokenSuperuser);
+        UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+        String pidA = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
+        String pidB = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
+        String externalIdentifier = "https://example.org/dataset/relations-summary";
+
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        JsonArray relations = Json.createArrayBuilder()
+                .add(Json.createObjectBuilder()
+                        .add("relatedDatasetPid", pidB)
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(Json.createObjectBuilder()
+                        .add("externalIdentifier", externalIdentifier)
+                        .add("identifierScheme", "URL")
+                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                .build();
+        UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.compareDatasetVersions(pidA, "1.0", "2.0", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relationsAdded", hasSize(2))
+                .body("data.relationsAdded.relatedDatasetPid", hasItem(pidB))
+                .body("data.relationsAdded.externalIdentifier", hasItem(externalIdentifier));
+        UtilIT.summaryDatasetVersionDifferences(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data[0].summary.relations.added", equalTo(2))
+                .body("data[0].summary.relations.removed", equalTo(0));
+
+        UtilIT.replaceDatasetRelations(pidA, "[]", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode());
+        UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
+
+        UtilIT.compareDatasetVersions(pidA, "2.0", "3.0", apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.relationsRemoved", hasSize(2))
+                .body("data.relationsRemoved.relatedDatasetPid", hasItem(pidB))
+                .body("data.relationsRemoved.externalIdentifier", hasItem(externalIdentifier));
+        UtilIT.summaryDatasetVersionDifferences(pidA, apiTokenSuperuser)
+                .then().assertThat().statusCode(OK.getStatusCode())
+                .body("data[0].summary.relations.removed", equalTo(2));
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index edec890b2e9..3ee99331da7 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -835,6 +835,15 @@ static Response updateDatasetMetadataViaNative(String persistentId, String pathT
                 .put("/api/datasets/:persistentId/versions/" + DS_VERSION_DRAFT + "?persistentId=" + persistentId);
         return response;
     }
+
+    static Response updateDatasetMetadataViaNative(String persistentId, JsonObject json, String apiToken) {
+        Response response = given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(json.toString())
+                .contentType("application/json")
+                .put("/api/datasets/:persistentId/versions/" + DS_VERSION_DRAFT + "?persistentId=" + persistentId);
+        return response;
+    }
     
     // https://github.com/IQSS/dataverse/issues/3777
     static Response addDatasetMetadataViaNative(String persistentId, String pathToJsonFile, String apiToken) {
@@ -5647,4 +5656,136 @@ public static String generateGuestbookResponse(Guestbook gb) throws IOException
                 .replace("@QID3", cqIDs.get(2).toString())
                 .replace("@QID4", cqIDs.get(3).toString());
     }
+    public static Response replaceDatasetRelations(String persistentId, String jsonBody, String apiToken) {
+        return replaceDatasetRelations(persistentId, jsonBody, null, apiToken);
+    }
+
+    public static Response replaceDatasetRelations(String persistentId, String jsonBody, String version, String apiToken) {
+        String path = "/api/datasets/:persistentId/relations?persistentId=" + persistentId;
+        if (version != null) {
+            path += "&version=" + version;
+        }
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType(ContentType.JSON)
+                .body(jsonBody)
+                .put(path);
+    }
+
+    public static Response listDatasetRelations(String persistentId) {
+        return listDatasetRelations(persistentId, null, null, null, null, null, null, null);
+    }
+
+    public static Response listDatasetRelations(String persistentId, String apiToken) {
+        return listDatasetRelations(persistentId, null, null, null, null, null, null, apiToken);
+    }
+
+    public static Response listDatasetRelations(String persistentId, String version, List<String> types, List<String> datasetTypes, List<String> sources, Integer limit, Integer offset, String apiToken) {
+        return listDatasetRelations(persistentId, version, types, datasetTypes, sources, limit, offset, apiToken, false);
+    }
+
+    public static Response listDatasetRelations(String persistentId, String version, List<String> types, List<String> datasetTypes,
+            List<String> sources, Integer limit, Integer offset, String apiToken, boolean showFacets) {
+        String path = "/api/datasets/:persistentId/relations?persistentId=" + persistentId;
+        if (version != null) {
+            path += "&version=" + version;
+        }
+        if (types != null) {
+            for (String t : types) {
+                path += "&type=" + t;
+            }
+        }
+        if (datasetTypes != null) {
+            for (String dt : datasetTypes) {
+                path += "&datasetType=" + dt;
+            }
+        }
+        if (sources != null) {
+            for (String s : sources) {
+                path += "&source=" + s;
+            }
+        }
+        if (limit != null) {
+            path += "&limit=" + limit;
+        }
+        if (offset != null) {
+            path += "&offset=" + offset;
+        }
+        if (showFacets) {
+            path += "&showFacets=true";
+        }
+        if (apiToken != null && !apiToken.isEmpty()) {
+            return given().header(API_TOKEN_HTTP_HEADER, apiToken).get(path);
+        } else {
+            return given().get(path);
+        }
+    }
+
+    public static Response addDatasetRelation(String persistentId, String jsonBody, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType(ContentType.JSON)
+                .body(jsonBody)
+                .post("/api/datasets/:persistentId/relations?persistentId=" + persistentId);
+    }
+
+    public static Response getDatasetRelation(String persistentId, long relationId, String apiToken) {
+        String path = "/api/datasets/:persistentId/relations/" + relationId + "?persistentId=" + persistentId;
+        if (apiToken != null && !apiToken.isEmpty()) {
+            return given().header(API_TOKEN_HTTP_HEADER, apiToken).get(path);
+        } else {
+            return given().get(path);
+        }
+    }
+
+    public static Response deleteDatasetRelation(String persistentId, long relationId, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .delete("/api/datasets/:persistentId/relations/" + relationId + "?persistentId=" + persistentId);
+    }
+
+    public static Response listDatasetRelationTypes(String apiToken) {
+        String path = "/api/datasets/relationTypes";
+        if (apiToken != null && !apiToken.isEmpty()) {
+            return given().header(API_TOKEN_HTTP_HEADER, apiToken).get(path);
+        } else {
+            return given().get(path);
+        }
+    }
+
+    public static Response getDatasetRelationType(String nameOrId, String apiToken) {
+        String path = "/api/datasets/relationTypes/" + nameOrId;
+        if (apiToken != null && !apiToken.isEmpty()) {
+            return given().header(API_TOKEN_HTTP_HEADER, apiToken).get(path);
+        } else {
+            return given().get(path);
+        }
+    }
+
+    public static Response getDefaultDatasetRelationType(String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .get("/api/datasets/relationTypes/defaultRelationType");
+    }
+
+    public static Response setDefaultDatasetRelationType(String nameOrId, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .put("/api/datasets/relationTypes/defaultRelationType/" + nameOrId);
+    }
+
+    public static Response addDatasetRelationType(String jsonIn, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType(ContentType.JSON)
+                .body(jsonIn)
+                .post("/api/datasets/relationTypes");
+    }
+
+    public static Response deleteDatasetRelationType(String nameOrId, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .delete("/api/datasets/relationTypes/" + nameOrId);
+    }
+
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexingTest.java b/src/test/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexingTest.java
new file mode 100644
index 00000000000..1db5c14cf44
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/datasetrelation/DatasetRelationIndexingTest.java
@@ -0,0 +1,85 @@
+package edu.harvard.iq.dataverse.datasetrelation;
+
+import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.search.IndexServiceBean;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Vera Clemens (ZB MED)
+ */
+public class DatasetRelationIndexingTest {
+
+    @Test
+    void schedulesDefiningDatasetAndChangedInternalRelatedDatasetsForReindexing() {
+        Dataset definingDataset = dataset(1L);
+        Dataset removedRelatedDataset = dataset(2L);
+        Dataset addedRelatedDataset = dataset(3L);
+        CommandContext ctxt = mock(CommandContext.class);
+        IndexServiceBean index = mock(IndexServiceBean.class);
+        when(ctxt.index()).thenReturn(index);
+
+        DatasetRelationIndexing.scheduleChanges(ctxt, definingDataset,
+                List.of(internalRelation(removedRelatedDataset)),
+                List.of(internalRelation(addedRelatedDataset)));
+
+        ArgumentCaptor<List<Dataset>> datasets = ArgumentCaptor.forClass(List.class);
+        verify(index).asyncIndexDatasetList(datasets.capture(), eq(true));
+        assertEquals(List.of(removedRelatedDataset, addedRelatedDataset, definingDataset), datasets.getValue());
+    }
+
+    @Test
+    void doesNotScheduleUnchangedInternalRelatedDatasetsForReindexing() {
+        Dataset definingDataset = dataset(1L);
+        Dataset relatedDataset = dataset(2L);
+        CommandContext ctxt = mock(CommandContext.class);
+        IndexServiceBean index = mock(IndexServiceBean.class);
+        when(ctxt.index()).thenReturn(index);
+
+        DatasetRelationIndexing.scheduleChanges(ctxt, definingDataset,
+                List.of(internalRelation(relatedDataset)),
+                List.of(internalRelation(relatedDataset)));
+
+        ArgumentCaptor<List<Dataset>> datasets = ArgumentCaptor.forClass(List.class);
+        verify(index).asyncIndexDatasetList(datasets.capture(), eq(true));
+        assertEquals(List.of(definingDataset), datasets.getValue());
+    }
+
+    @Test
+    void schedulesRelatedDatasetWhenItsRelationCountChanges() {
+        Dataset definingDataset = dataset(1L);
+        Dataset relatedDataset = dataset(2L);
+        CommandContext ctxt = mock(CommandContext.class);
+        IndexServiceBean index = mock(IndexServiceBean.class);
+        when(ctxt.index()).thenReturn(index);
+
+        DatasetRelationIndexing.scheduleChanges(ctxt, definingDataset,
+                List.of(internalRelation(relatedDataset)),
+                List.of(internalRelation(relatedDataset), internalRelation(relatedDataset)));
+
+        ArgumentCaptor<List<Dataset>> datasets = ArgumentCaptor.forClass(List.class);
+        verify(index).asyncIndexDatasetList(datasets.capture(), eq(true));
+        assertEquals(List.of(relatedDataset, definingDataset), datasets.getValue());
+    }
+
+    private Dataset dataset(Long id) {
+        Dataset dataset = mock(Dataset.class);
+        when(dataset.getId()).thenReturn(id);
+        return dataset;
+    }
+
+    private DatasetRelation internalRelation(Dataset relatedDataset) {
+        InternalDatasetRelation relation = mock(InternalDatasetRelation.class);
+        when(relation.getRelatedDataset()).thenReturn(relatedDataset);
+        return relation;
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/PermissionTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/PermissionTest.java
index 4b98d3d9850..a80ba844d7e 100644
--- a/src/test/java/edu/harvard/iq/dataverse/engine/PermissionTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/PermissionTest.java
@@ -27,6 +27,10 @@ public void testAppliesTo() {
         assertTrue( Permission.EditDataset.appliesTo(Dataset.class) );
         assertFalse( Permission.EditDataset.appliesTo(DvObject.class) );
         assertFalse( Permission.EditDataset.appliesTo(Dataverse.class) );
+
+        assertTrue(Permission.EditDatasetRelations.appliesTo(Dataset.class));
+        assertFalse(Permission.EditDatasetRelations.appliesTo(DvObject.class));
+        assertFalse(Permission.EditDatasetRelations.appliesTo(Dataverse.class));
     }
     
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java b/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
index 573c0f48a53..b98042d7522 100644
--- a/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
@@ -9,6 +9,8 @@
 import edu.harvard.iq.dataverse.confirmemail.ConfirmEmailServiceBean;
 import edu.harvard.iq.dataverse.datacapturemodule.DataCaptureModuleServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetFieldsValidator;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationTypeServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.engine.command.Command;
@@ -244,6 +246,16 @@ public DatasetTypeServiceBean datasetTypes() {
         return null;
     }
 
+    @Override
+    public DatasetRelationServiceBean datasetRelations() {
+        return null;
+    }
+
+    @Override
+    public DatasetRelationTypeServiceBean datasetRelationTypes() {
+        return null;
+    }
+
     @Override
     public StorageUseServiceBean storageUse() {
         return null;
diff --git a/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java b/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java
index 7a24670fae1..22600fc8b38 100644
--- a/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java
@@ -2,6 +2,7 @@
 
 import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.branding.BrandingUtilTest;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
 import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.license.LicenseServiceBean;
@@ -48,6 +49,7 @@ public class SchemaDotOrgExporterTest {
     private static final LicenseServiceBean licenseService = Mockito.mock(LicenseServiceBean.class);
     private static final DatasetTypeServiceBean datasetTypeService = Mockito.mock(DatasetTypeServiceBean.class);
     private static final TemplateServiceBean templateService = Mockito.mock(TemplateServiceBean.class);
+    private static final DatasetRelationServiceBean datasetRelationService = Mockito.mock(DatasetRelationServiceBean.class);
     private static final SchemaDotOrgExporter schemaDotOrgExporter = new SchemaDotOrgExporter();
 
     @BeforeAll
@@ -185,7 +187,7 @@ public void testExportWithoutDownloadUrl() throws IOException, JsonParseExceptio
     private JsonObject createExportFromJson(ExportDataProvider provider) throws JsonParseException, ParseException {
         License license = new License("CC0 1.0", "You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.", URI.create("http://creativecommons.org/publicdomain/zero/1.0/"), URI.create("/resources/images/cc0.png"), true, 1l);
         license.setDefault(true);
-        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService);
+        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
         DatasetVersion version = jsonParser.parseDatasetVersion(provider.getDatasetJson().getJsonObject("datasetVersion"));
         version.setVersionState(DatasetVersion.VersionState.RELEASED);
         SimpleDateFormat dateFmt = new SimpleDateFormat("yyyyMMdd");
diff --git a/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java b/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java
index 2861250e43c..8a0de794879 100644
--- a/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java
@@ -2,6 +2,7 @@
 
 import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
 import edu.harvard.iq.dataverse.license.LicenseServiceBean;
 import edu.harvard.iq.dataverse.mocks.MockDatasetFieldSvc;
@@ -46,6 +47,7 @@ public class FeedbackUtilTest {
     private static final LicenseServiceBean licenseService = Mockito.mock(LicenseServiceBean.class);
     private static final DatasetTypeServiceBean datasetTypeService = Mockito.mock(DatasetTypeServiceBean.class);
     private static final TemplateServiceBean templateService = Mockito.mock(TemplateServiceBean.class);
+    private static final DatasetRelationServiceBean datasetRelationService = Mockito.mock(DatasetRelationServiceBean.class);
     private static final String systemEmail = "support@librascholar.edu";
     private static final boolean weKnowHowToCreateMockAuthenticatedUsers = false;
 
@@ -131,16 +133,16 @@ public static void setUpClass() throws IOException, JsonParseException, AddressE
 
         JsonObject json1 = JsonUtil.getJsonObjectFromFile("src/test/resources/json/dataset-finch1.json");
 
-        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService);
+        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
         dsVersion = jsonParser.parseDatasetVersion(json1.getJsonObject("datasetVersion"));
 
         JsonObject json12 = JsonUtil.getJsonObjectFromFile("tests/data/datasetContacts1.json");
 
-        JsonParser jsonParser2 = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService);
+        JsonParser jsonParser2 = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
         dsVersion2 = jsonParser2.parseDatasetVersion(json12.getJsonObject("datasetVersion"));
 
         JsonObject jsonNoContacts = JsonUtil.getJsonObjectFromFile("tests/data/datasetNoContacts.json");
-        JsonParser jsonParserNoContacts = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService);
+        JsonParser jsonParserNoContacts = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
         dsVersionNoContacts = jsonParserNoContacts.parseDatasetVersion(jsonNoContacts.getJsonObject("datasetVersion"));
 
         FeedbackUtil justForCodeCoverage = new FeedbackUtil();
diff --git a/src/test/java/edu/harvard/iq/dataverse/pidproviders/doi/datacite/XmlMetadataTemplateTest.java b/src/test/java/edu/harvard/iq/dataverse/pidproviders/doi/datacite/XmlMetadataTemplateTest.java
index 19da198399a..2092d057583 100644
--- a/src/test/java/edu/harvard/iq/dataverse/pidproviders/doi/datacite/XmlMetadataTemplateTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/pidproviders/doi/datacite/XmlMetadataTemplateTest.java
@@ -19,6 +19,8 @@
 import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
 import edu.harvard.iq.dataverse.branding.BrandingUtil;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.InternalDatasetRelation;
 import edu.harvard.iq.dataverse.pidproviders.PidProviderFactoryBean;
 import edu.harvard.iq.dataverse.pidproviders.doi.DoiMetadata;
 import edu.harvard.iq.dataverse.pidproviders.doi.XmlMetadataTemplate;
@@ -251,6 +253,16 @@ public void testDataCiteXMLCreation() throws IOException {
         dType.setName(DatasetType.DATASET_TYPE_DATASET);
         d.setDatasetType(dType);
 
+        Dataset relatedDataset = new Dataset();
+        relatedDataset.setGlobalId(new GlobalId("doi", "10.5072", "FK2/RELATED", null, null, null));
+        Dataset customRelatedDataset = new Dataset();
+        customRelatedDataset.setGlobalId(new GlobalId("doi", "10.5072", "FK2/CUSTOM", null, null, null));
+        DatasetRelationType cites = new DatasetRelationType("Cites", "Cites");
+        DatasetRelationType custom = new DatasetRelationType("CustomRelation", "Custom relation");
+        dv.setRelations(List.of(
+                new InternalDatasetRelation(d, relatedDataset, cites, dv),
+                new InternalDatasetRelation(d, customRelatedDataset, custom, dv)));
+
         String xml = template.generateXML(d);
         System.out.println("Output from minimal example is " + xml);
         try {
@@ -272,6 +284,10 @@ public void testDataCiteXMLCreation() throws IOException {
         assertEquals("ROR", XmlPath.from(xml).getString("resource.creators.creator[2].nameIdentifier.@nameIdentifierScheme"));
         assertEquals("https://ror.org", XmlPath.from(xml).getString("resource.creators.creator[2].nameIdentifier.@schemeURI"));
         assertEquals("Qualitative Data Repository", XmlPath.from(xml).getString("resource.creators.creator[3].creatorName"));
+        assertEquals("10.5072/FK2/RELATED", XmlPath.from(xml).getString("resource.relatedIdentifiers.relatedIdentifier[0]"));
+        assertEquals("DOI", XmlPath.from(xml).getString("resource.relatedIdentifiers.relatedIdentifier[0].@relatedIdentifierType"));
+        assertEquals("Cites", XmlPath.from(xml).getString("resource.relatedIdentifiers.relatedIdentifier[0].@relationType"));
+        assertFalse(xml.contains("FK2/CUSTOM"));
         //Test when URL form was used
         assertEquals("https://ror.org/014trz974", XmlPath.from(xml).getString("resource.creators.creator[3].nameIdentifier"));
         assertEquals("ROR", XmlPath.from(xml).getString("resource.creators.creator[3].nameIdentifier.@nameIdentifierScheme"));
diff --git a/src/test/java/edu/harvard/iq/dataverse/search/IndexServiceBeanTest.java b/src/test/java/edu/harvard/iq/dataverse/search/IndexServiceBeanTest.java
index eda9b995db5..7f23b1eaf91 100644
--- a/src/test/java/edu/harvard/iq/dataverse/search/IndexServiceBeanTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/search/IndexServiceBeanTest.java
@@ -17,6 +17,7 @@
 import edu.harvard.iq.dataverse.GlobalId;
 import edu.harvard.iq.dataverse.MetadataBlock;
 import edu.harvard.iq.dataverse.branding.BrandingUtil;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.mocks.MocksFactory;
 import edu.harvard.iq.dataverse.pidproviders.doi.AbstractDOIProvider;
@@ -69,6 +70,7 @@ public void setUp() {
         indexService.datasetFieldService = Mockito.mock(DatasetFieldServiceBean.class);
         indexService.datasetVersionService = Mockito.mock(DatasetVersionServiceBean.class);
         indexService.datasetVersionFilesServiceBean = Mockito.mock(DatasetVersionFilesServiceBean.class);
+        indexService.datasetRelationService = Mockito.mock(DatasetRelationServiceBean.class);
         BrandingUtil.injectServices(indexService.dataverseService, indexService.settingsService);
 
         Mockito.when(indexService.dataverseService.findRootDataverse()).thenReturn(dataverse);
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
index 5163a29a974..676f1ad32e0 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
@@ -16,6 +16,7 @@
 import edu.harvard.iq.dataverse.authorization.groups.impl.maildomain.MailDomainGroup;
 import edu.harvard.iq.dataverse.authorization.groups.impl.maildomain.MailDomainGroupTest;
 import edu.harvard.iq.dataverse.authorization.users.GuestUser;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
@@ -24,6 +25,7 @@
 import edu.harvard.iq.dataverse.mocks.MockDatasetFieldSvc;
 import edu.harvard.iq.dataverse.pidproviders.doi.AbstractDOIProvider;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
+import edu.harvard.iq.dataverse.api.dto.DatasetRelationDTO;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.BeforeEach;
@@ -58,6 +60,7 @@ public class JsonParserTest {
     LicenseServiceBean licenseService = Mockito.mock(LicenseServiceBean.class);
     DatasetTypeServiceBean datasetTypeService = Mockito.mock(DatasetTypeServiceBean.class);
     TemplateServiceBean templateService = Mockito.mock(TemplateServiceBean.class);
+    DatasetRelationServiceBean datasetRelationService = Mockito.mock(DatasetRelationServiceBean.class);
     DatasetFieldType keywordType;
     DatasetFieldType descriptionType;
     DatasetFieldType subjectType;
@@ -173,7 +176,7 @@ public void setUp() {
         datasetType.setName(DatasetType.DEFAULT_DATASET_TYPE);
         datasetType.setId(1l);
         Mockito.when(datasetTypeService.getByName(DatasetType.DEFAULT_DATASET_TYPE)).thenReturn(datasetType);
-        sut = new JsonParser(datasetFieldTypeSvc, null, settingsSvc, licenseService, datasetTypeService, templateService);
+        sut = new JsonParser(datasetFieldTypeSvc, null, settingsSvc, licenseService, datasetTypeService, templateService, datasetRelationService);
     }
     
     @Test 
@@ -757,7 +760,7 @@ public void testParseDatasetVersion_LicenseAndTerms() throws JsonParseException
         Mockito.when(licenseService.getDefault()).thenReturn(defaultLicense);
 
         String baseJson = "{\"metadataBlocks\":{\"citation\":{\"fields\":[]}}}";
-        
+
         // Case 1: Flag false (default), terms NOT provided -> should pick default
         System.setProperty("dataverse.feature.do-not-assume-default-license", "false");
         DatasetVersion dsv1 = sut.parseDatasetVersion(JsonUtil.getJsonObject(baseJson));
@@ -773,14 +776,14 @@ public void testParseDatasetVersion_LicenseAndTerms() throws JsonParseException
         System.setProperty("dataverse.feature.do-not-assume-default-license", "true");
         DatasetVersion dsv3 = sut.parseDatasetVersion(JsonUtil.getJsonObject(baseJson));
         assertNull(dsv3.getTermsOfUseAndAccess().getLicense());
-        
+
         // Cleanup
         System.clearProperty("dataverse.feature.do-not-assume-default-license");
     }
 
     private static class MockSettingsSvc extends SettingsServiceBean {
         private boolean allowCustomTermsOfUse = false;
-        
+
         public void setAllowCustomTermsOfUse(boolean allow) {
             this.allowCustomTermsOfUse = allow;
         }
@@ -831,6 +834,19 @@ public void testGuestbook() throws JsonParseException {
         assertEquals(3, gb.getCustomQuestions().get(2).getCustomQuestionValues().get(3).getDisplayOrder());
     }
 
+    @Test
+    public void testParseExternalDatasetRelationDTOWithDatasetType() throws JsonParseException {
+        String json = "{\"externalIdentifier\":\"10.1234/ext-1\", \"identifierScheme\":\"doi\", \"datasetType\":\"Journal Article\", \"relationTypeName\":\"isReferencedBy\"}";
+        JsonObject jsonObject = JsonUtil.getJsonObject(json);
+        DatasetRelationDTO dto = sut.parseDatasetRelationDTO(jsonObject);
+
+        assertNotNull(dto);
+        assertEquals("10.1234/ext-1", dto.getExternalIdentifier());
+        assertEquals("doi", dto.getIdentifierScheme());
+        assertEquals("Journal Article", dto.getDatasetType());
+        assertEquals("isReferencedBy", dto.getRelationTypeName());
+    }
+
     @Test
     public void testGuestbookResponse() throws JsonParseException {
         JsonObject jsonObj = JsonUtil.getJsonObject(guestbookJson);
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
index 95a3fbef20e..e46db5f2adb 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
@@ -8,6 +8,9 @@
 import edu.harvard.iq.dataverse.authorization.users.PrivateUrlUser;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.datasetrelation.DatasetRelationType;
+import edu.harvard.iq.dataverse.datasetrelation.ExternalDatasetRelation;
+import edu.harvard.iq.dataverse.datasetrelation.InternalDatasetRelation;
 import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.mocks.MockDatasetFieldSvc;
 import edu.harvard.iq.dataverse.pidproviders.doi.AbstractDOIProvider;
@@ -478,7 +481,7 @@ public void testDatasetWithNondefaultType() {
         Dataset dataset = createDataset(42);
         dataset.setDatasetType(foobar);
         
-        var jsob = JsonPrinter.json(dataset.getLatestVersion(), false, false).build();
+        var jsob = JsonPrinter.json(dataset.getLatestVersion(), false, false, false).build();
         String result = jsob.getString("datasetType");
         
         assertNotNull(result);
@@ -832,4 +835,81 @@ public void testJsonStorageDriver() {
         System.clearProperty("dataverse.files.test-driver4.type");
         System.clearProperty("dataverse.files.test-driver4.label");
     }
+
+    @Test
+    public void testPrintExternalDatasetRelation() {
+        Dataset dataset = new Dataset();
+        dataset.setId(1L);
+        dataset.setProtocol("doi");
+        dataset.setAuthority("10.5072");
+        dataset.setIdentifier("FK2/ORIG");
+
+        DatasetVersion version = new DatasetVersion();
+        version.setId(10L);
+        version.setDataset(dataset);
+
+        DatasetRelationType type = new DatasetRelationType("isReferencedBy", "Is referenced by");
+
+        ExternalDatasetRelation rel = new ExternalDatasetRelation(dataset, "10.1234/ext-1", "doi", "Journal Article", type, version);
+
+        JsonObject result = JsonPrinter.json(rel, false, false).build();
+
+        assertEquals("doi:10.5072/FK2/ORIG", result.getString("datasetPid"));
+        assertEquals("10.1234/ext-1", result.getString("externalIdentifier"));
+        assertEquals("doi", result.getString("identifierScheme"));
+        assertEquals("isReferencedBy", result.getJsonObject("relationType").getString("name"));
+        assertEquals("Is referenced by", result.getJsonObject("relationType").getString("displayName"));
+        assertEquals("Journal Article", result.getJsonObject("relatedDatasetType").getString("displayName"));
+    }
+
+    @Test
+    public void testPrintInternalDatasetRelation() {
+        Dataset datasetA = new Dataset();
+        datasetA.setId(1L);
+        datasetA.setProtocol("doi");
+        datasetA.setAuthority("10.5072");
+        datasetA.setIdentifier("FK2/A");
+        DatasetType typeA = new DatasetType();
+        typeA.setName("dataset");
+        typeA.setDisplayName("Dataset");
+        datasetA.setDatasetType(typeA);
+
+        Dataset datasetB = new Dataset();
+        datasetB.setId(2L);
+        datasetB.setProtocol("doi");
+        datasetB.setAuthority("10.5072");
+        datasetB.setIdentifier("FK2/B");
+        DatasetType typeB = new DatasetType();
+        typeB.setName("software");
+        typeB.setDisplayName("Software");
+        datasetB.setDatasetType(typeB);
+
+        DatasetVersion version = new DatasetVersion();
+        version.setId(10L);
+        version.setDataset(datasetA);
+
+        DatasetRelationType relType = new DatasetRelationType("isReferencedBy", "Is referenced by");
+        DatasetRelationType relTypeInv = new DatasetRelationType("references", "References", null, relType);
+
+        InternalDatasetRelation rel = new InternalDatasetRelation(datasetA, datasetB, relType, version);
+
+        // Printing with invertRelation = false
+        JsonObject result = JsonPrinter.json(rel, false, false).build();
+
+        assertEquals("doi:10.5072/FK2/A", result.getString("datasetPid"));
+        assertEquals("doi:10.5072/FK2/B", result.getString("relatedDatasetPid"));
+        assertEquals("isReferencedBy", result.getJsonObject("relationType").getString("name"));
+        assertEquals("Is referenced by", result.getJsonObject("relationType").getString("displayName"));
+        assertEquals("software", result.getJsonObject("relatedDatasetType").getString("name"));
+        assertEquals("Software", result.getJsonObject("relatedDatasetType").getString("displayName"));
+
+        // Printing with invertRelation = true
+        JsonObject resultInverted = JsonPrinter.json(rel, true, false).build();
+        assertEquals("doi:10.5072/FK2/B", resultInverted.getString("datasetPid"));
+        assertEquals("doi:10.5072/FK2/A", resultInverted.getString("relatedDatasetPid"));
+        assertEquals("references", resultInverted.getJsonObject("relationType").getString("name"));
+        assertEquals("References", resultInverted.getJsonObject("relationType").getString("displayName"));
+        assertEquals("dataset", resultInverted.getJsonObject("relatedDatasetType").getString("name"));
+        assertEquals("Dataset", resultInverted.getJsonObject("relatedDatasetType").getString("displayName"));
+    }
 }
diff --git a/tests/integration-tests.txt b/tests/integration-tests.txt
index 77bfe683545..6ee373ec4e4 100644
--- a/tests/integration-tests.txt
+++ b/tests/integration-tests.txt
@@ -1 +1 @@
-DataversesIT,DatasetsIT,SwordIT,AdminIT,BuiltinUsersIT,UsersIT,UtilIT,ConfirmEmailIT,FileMetadataIT,FilesIT,SearchIT,InReviewWorkflowIT,HarvestingServerIT,HarvestingClientsIT,MoveIT,MakeDataCountApiIT,FileTypeDetectionIT,EditDDIIT,ExternalToolsIT,AccessIT,DuplicateFilesIT,DownloadFilesIT,LinkIT,DeleteUsersIT,DeactivateUsersIT,AuxiliaryFilesIT,InvalidCharactersIT,LicensesIT,NotificationsIT,BagIT,MetadataBlocksIT,NetcdfIT,SignpostingIT,FitsIT,LogoutIT,DataRetrieverApiIT,ProvIT,S3AccessIT,OpenApiIT,InfoIT,DatasetFieldsIT,SavedSearchIT,DatasetTypesIT,DataverseFeaturedItemsIT,SendFeedbackApiIT,CustomizationIT,JsonLDExportIT,WorkflowsIT,LDNInboxIT,LocalContextsIT,CorsIT,GuestbooksIT,LocallyFairIT
+DataversesIT,DatasetsIT,SwordIT,AdminIT,BuiltinUsersIT,UsersIT,UtilIT,ConfirmEmailIT,FileMetadataIT,FilesIT,SearchIT,InReviewWorkflowIT,HarvestingServerIT,HarvestingClientsIT,MoveIT,MakeDataCountApiIT,FileTypeDetectionIT,EditDDIIT,ExternalToolsIT,AccessIT,DuplicateFilesIT,DownloadFilesIT,LinkIT,DeleteUsersIT,DeactivateUsersIT,AuxiliaryFilesIT,InvalidCharactersIT,LicensesIT,NotificationsIT,BagIT,MetadataBlocksIT,NetcdfIT,SignpostingIT,FitsIT,LogoutIT,DataRetrieverApiIT,ProvIT,S3AccessIT,OpenApiIT,InfoIT,DatasetFieldsIT,SavedSearchIT,DatasetTypesIT,DataverseFeaturedItemsIT,SendFeedbackApiIT,CustomizationIT,JsonLDExportIT,WorkflowsIT,LDNInboxIT,LocalContextsIT,CorsIT,GuestbooksIT,LocallyFairIT,DatasetRelationsIT,DatasetRelationTypesIT
diff --git a/tests/performance/relations/README.md b/tests/performance/relations/README.md
new file mode 100644
index 00000000000..4d5bb5f6459
--- /dev/null
+++ b/tests/performance/relations/README.md
@@ -0,0 +1,58 @@
+# Dataset relation listing benchmark
+
+This opt-in benchmark measures performance of `GET /api/datasets/{identifier}/relations` with a setup mimicking realistic database state: many released source datasets each define an internal relation pointing at one released target dataset. It exercises incoming relations, latest-released-version resolution, deduplication, ordering, pagination, and the endpoint's total-count query.
+
+It is intentionally separate from integration tests. The runner reports measurements instead of enforcing a threshold.
+
+## Prerequisites
+
+- A local Dataverse instance running against PostgreSQL.
+- `psql` and `curl` on the host.
+- An API token for a superuser, or a user who can create a collection under the chosen parent and create relation types.
+- `jq` for reading native-API responses.
+
+The seed script creates and publishes its own temporary collection and target dataset through the native API, creates a self-inverse relation type, and then clones the target dataset's database rows to make synthetic released source datasets. Use a disposable local database only. The cleanup script removes the synthetic source rows created by this benchmark.
+
+## Seed the fixture
+
+Seed a temporary collection, a target dataset, a number of source datasets, and an incoming internal relation from each source dataset to the target dataset. By default, 10,000 source datasets/relations are created. Use `-n` to select a different number.
+
+```sh
+tests/performance/relations/seed.sh \
+  -d 'postgresql://dataverse:secret@localhost:5432/dataverse' \
+  -b http://localhost:8080 \
+  -k '<superuser-api-token>'
+```
+
+Pass `-p parent-alias` to create the temporary collection below a collection other than `root`. The script prints the generated target PID for use by the measurement command and runs `ANALYZE` after seeding.
+
+## Measure the API
+
+Run a warm-up followed by 20 timed requests. By default, the endpoint uses `limit=10` and includes related dataset metadata. Use `-l` to select the page size and `-m true|false` to configure `includeMetadataBlocks`.
+
+```sh
+tests/performance/relations/measure-list.sh \
+  -b http://localhost:8080 \
+  -p 'doi:10.5072/FK2/EXAMPLE'
+```
+
+The runner logs each warm-up and measured request, then prints min, median, p95, max, and mean durations. It uses a 10-second connection timeout and a 120-second request timeout, so a stalled request reports a failure instead of waiting indefinitely.
+
+## Inspect query plans
+
+The API endpoint executes a list query and a total-count query. Capture the actual PostgreSQL plans for the same benchmark dataset with:
+
+```sh
+tests/performance/relations/explain.sh \
+  -d 'postgresql://dataverse:secret@localhost:5432/dataverse' \
+  -p 'doi:10.5072/FK2/EXAMPLE'
+```
+
+The script resolves the dataset and its latest released version, then runs both queries from `SqlDirectDatasetRelationAlgorithm` with `EXPLAIN (ANALYZE, BUFFERS)`. The output contains actual execution time, row estimates versus row counts, and buffer reads/hits.
+
+## Clean up
+
+```sh
+tests/performance/relations/cleanup.sh \
+  -d 'postgresql://dataverse:secret@localhost:5432/dataverse'
+```
diff --git a/tests/performance/relations/cleanup.sh b/tests/performance/relations/cleanup.sh
new file mode 100755
index 00000000000..10003c07696
--- /dev/null
+++ b/tests/performance/relations/cleanup.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+set -eu
+
+usage() {
+    echo "Usage: $0 -d DATABASE_URL" >&2
+    exit 1
+}
+
+databaseUrl=
+
+while getopts "d:" option; do
+    case "$option" in
+        d) databaseUrl=$OPTARG ;;
+        *) usage ;;
+    esac
+done
+
+[ -n "$databaseUrl" ] || usage
+
+scriptDirectory=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+printf 'Cleaning up benchmark data in PostgreSQL\n' >&2
+psql "$databaseUrl" \
+    -f "$scriptDirectory/cleanup.sql"
diff --git a/tests/performance/relations/cleanup.sql b/tests/performance/relations/cleanup.sql
new file mode 100644
index 00000000000..315d3d83517
--- /dev/null
+++ b/tests/performance/relations/cleanup.sql
@@ -0,0 +1,26 @@
+\set ON_ERROR_STOP on
+
+-- Removes only synthetic datasets created by seed-internal-relations.sql.
+WITH benchmark_datasets AS (
+    SELECT id FROM dvobject WHERE identifier LIKE 'benchmark-relation-%'
+)
+DELETE FROM datasetrelation
+WHERE dataset_id IN (SELECT id FROM benchmark_datasets)
+   OR relateddataset_id IN (SELECT id FROM benchmark_datasets);
+
+WITH benchmark_datasets AS (
+    SELECT id FROM dvobject WHERE identifier LIKE 'benchmark-relation-%'
+)
+DELETE FROM datasetversion WHERE dataset_id IN (SELECT id FROM benchmark_datasets);
+
+WITH benchmark_datasets AS (
+    SELECT id FROM dvobject WHERE identifier LIKE 'benchmark-relation-%'
+)
+DELETE FROM dataset WHERE id IN (SELECT id FROM benchmark_datasets);
+
+DELETE FROM dvobject WHERE identifier LIKE 'benchmark-relation-%';
+
+ANALYZE dvobject;
+ANALYZE dataset;
+ANALYZE datasetversion;
+ANALYZE datasetrelation;
diff --git a/tests/performance/relations/explain-list.sql b/tests/performance/relations/explain-list.sql
new file mode 100644
index 00000000000..a1564ef3ba2
--- /dev/null
+++ b/tests/performance/relations/explain-list.sql
@@ -0,0 +1,113 @@
+\set ON_ERROR_STOP on
+
+CREATE TEMP TABLE relation_benchmark_target AS
+SELECT d.id AS dataset_id,
+       (
+           SELECT dv.id
+           FROM datasetversion dv
+           WHERE dv.dataset_id = d.id
+             AND dv.versionstate = 'RELEASED'
+           ORDER BY dv.id DESC
+           LIMIT 1
+       ) AS version_id
+FROM dataset d
+JOIN dvobject o ON o.id = d.id
+WHERE o.protocol || ':' || o.authority || o.separator || o.identifier = :'persistent_id';
+
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM relation_benchmark_target WHERE version_id IS NOT NULL) THEN
+        RAISE EXCEPTION 'No released dataset found for the supplied persistent ID';
+    END IF;
+END;
+$$;
+
+SELECT dataset_id AS target_dataset_id, version_id AS target_version_id
+FROM relation_benchmark_target
+\gset
+
+\echo Capturing list-query plan for dataset :target_dataset_id and version :target_version_id
+EXPLAIN (ANALYZE, BUFFERS)
+WITH latest_released_versions AS MATERIALIZED (
+    SELECT DISTINCT ON (dataset_id) id, dataset_id
+    FROM datasetversion
+    WHERE versionstate = 'RELEASED'
+    ORDER BY dataset_id, id DESC
+),
+candidate_relations AS (
+    SELECT dr.id, 0 AS definition_point_priority
+    FROM datasetrelation dr
+    WHERE dr.definitionpoint_id = :target_version_id
+    UNION ALL
+    SELECT dr.id, 1 AS definition_point_priority
+    FROM datasetrelation dr
+    JOIN latest_released_versions lrv ON dr.definitionpoint_id = lrv.id
+    WHERE lrv.dataset_id != :target_dataset_id
+      AND dr.relateddataset_id = :target_dataset_id
+),
+normalized_candidate_relations AS (
+    SELECT cr.id, cr.definition_point_priority, dr.relation_source AS normalized_relation_source,
+           CASE
+               WHEN dr.dataset_id = :target_dataset_id THEN dr.relationtype_id
+               ELSE rt.inverse_id
+           END AS normalized_relation_type_id,
+           CASE WHEN dr.relation_source = 'internal'
+                THEN CASE WHEN dr.dataset_id = :target_dataset_id THEN CAST(dr.relateddataset_id AS VARCHAR) ELSE CAST(dr.dataset_id AS VARCHAR) END
+                ELSE dr.externalidentifier
+           END AS normalized_related_dataset
+    FROM candidate_relations cr
+    JOIN datasetrelation dr ON cr.id = dr.id
+    LEFT JOIN datasetrelationtype rt ON dr.relationtype_id = rt.id
+),
+deduplicated_relations AS (
+    SELECT DISTINCT ON (normalized_relation_source, normalized_relation_type_id, normalized_related_dataset) id, definition_point_priority
+    FROM normalized_candidate_relations
+    ORDER BY normalized_relation_source, normalized_relation_type_id, normalized_related_dataset, definition_point_priority, id
+)
+SELECT dr.*
+FROM deduplicated_relations cr
+JOIN datasetrelation dr ON cr.id = dr.id
+ORDER BY cr.definition_point_priority ASC, dr.id ASC
+LIMIT 10 OFFSET 0;
+
+\echo Capturing total-count-query plan for dataset :target_dataset_id and version :target_version_id
+EXPLAIN (ANALYZE, BUFFERS)
+WITH latest_released_versions AS MATERIALIZED (
+    SELECT DISTINCT ON (dataset_id) id, dataset_id
+    FROM datasetversion
+    WHERE versionstate = 'RELEASED'
+    ORDER BY dataset_id, id DESC
+),
+candidate_relations AS (
+    SELECT dr.id, 0 AS definition_point_priority
+    FROM datasetrelation dr
+    WHERE dr.definitionpoint_id = :target_version_id
+    UNION ALL
+    SELECT dr.id, 1 AS definition_point_priority
+    FROM datasetrelation dr
+    JOIN latest_released_versions lrv ON dr.definitionpoint_id = lrv.id
+    WHERE lrv.dataset_id != :target_dataset_id
+      AND dr.relateddataset_id = :target_dataset_id
+),
+normalized_candidate_relations AS (
+    SELECT cr.id, cr.definition_point_priority, dr.relation_source AS normalized_relation_source,
+           CASE
+               WHEN dr.dataset_id = :target_dataset_id THEN dr.relationtype_id
+               ELSE rt.inverse_id
+           END AS normalized_relation_type_id,
+           CASE WHEN dr.relation_source = 'internal'
+                THEN CASE WHEN dr.dataset_id = :target_dataset_id THEN CAST(dr.relateddataset_id AS VARCHAR) ELSE CAST(dr.dataset_id AS VARCHAR) END
+                ELSE dr.externalidentifier
+           END AS normalized_related_dataset
+    FROM candidate_relations cr
+    JOIN datasetrelation dr ON cr.id = dr.id
+    LEFT JOIN datasetrelationtype rt ON dr.relationtype_id = rt.id
+),
+deduplicated_relations AS (
+    SELECT DISTINCT ON (normalized_relation_source, normalized_relation_type_id, normalized_related_dataset) id, definition_point_priority
+    FROM normalized_candidate_relations
+    ORDER BY normalized_relation_source, normalized_relation_type_id, normalized_related_dataset, definition_point_priority, id
+)
+SELECT COUNT(*)
+FROM deduplicated_relations ddr
+JOIN datasetrelation dr ON ddr.id = dr.id;
diff --git a/tests/performance/relations/explain.sh b/tests/performance/relations/explain.sh
new file mode 100755
index 00000000000..35f8c42dfd3
--- /dev/null
+++ b/tests/performance/relations/explain.sh
@@ -0,0 +1,27 @@
+#!/bin/sh
+set -eu
+
+usage() {
+    echo "Usage: $0 -d DATABASE_URL -p DATASET_PID" >&2
+    exit 1
+}
+
+databaseUrl=
+datasetPid=
+
+while getopts "d:p:" option; do
+    case "$option" in
+        d) databaseUrl=$OPTARG ;;
+        p) datasetPid=$OPTARG ;;
+        *) usage ;;
+    esac
+done
+
+[ -n "$databaseUrl" ] && [ -n "$datasetPid" ] || usage
+
+scriptDirectory=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+printf 'Capturing query plans for relations of %s\n' "$datasetPid" >&2
+psql "$databaseUrl" \
+    --pset pager=off \
+    -v persistent_id="$datasetPid" \
+    -f "$scriptDirectory/explain-list.sql"
diff --git a/tests/performance/relations/measure-list.sh b/tests/performance/relations/measure-list.sh
new file mode 100755
index 00000000000..701ef55a44b
--- /dev/null
+++ b/tests/performance/relations/measure-list.sh
@@ -0,0 +1,80 @@
+#!/bin/sh
+set -eu
+
+usage() {
+    echo "Usage: $0 -b BASE_URL -p DATASET_PID [-l LIMIT] [-m INCLUDE_METADATA_BLOCKS] [-r REQUESTS] [-w WARMUPS]" >&2
+    exit 1
+}
+
+baseUrl=
+datasetPid=
+requests=20
+warmups=5
+limit=10
+includeMetadataBlocks=false
+connectTimeout=10
+requestTimeout=120
+
+while getopts "b:p:l:m:r:w:" option; do
+    case "$option" in
+        b) baseUrl=$OPTARG ;;
+        p) datasetPid=$OPTARG ;;
+        l) limit=$OPTARG ;;
+        m) includeMetadataBlocks=$OPTARG ;;
+        r) requests=$OPTARG ;;
+        w) warmups=$OPTARG ;;
+        *) usage ;;
+    esac
+done
+
+[ -n "$baseUrl" ] && [ -n "$datasetPid" ] || usage
+
+resultsFile=$(mktemp)
+trap 'rm -f "$resultsFile"' EXIT
+
+request() {
+    responseFile=$(mktemp)
+    if ! response=$(curl --silent --show-error --output "$responseFile" --write-out '%{http_code} %{time_total}' \
+        --connect-timeout "$connectTimeout" --max-time "$requestTimeout" \
+        --get --data-urlencode "persistentId=$datasetPid" --data "limit=$limit" \
+        --data "includeMetadataBlocks=$includeMetadataBlocks" \
+        "$baseUrl/api/datasets/:persistentId/relations"); then
+        response='000 0'
+    fi
+    statusCode=${response%% *}
+    elapsed=${response#* }
+    [ "$statusCode" = "200" ] || {
+        echo "Request failed with HTTP $statusCode after ${elapsed}s" >&2
+        cat "$responseFile" >&2
+        rm -f "$responseFile"
+        exit 1
+    }
+    rm -f "$responseFile"
+    echo "$elapsed"
+}
+
+warmup=1
+while [ "$warmup" -le "$warmups" ]; do
+    printf 'Warm-up request %s/%s\n' "$warmup" "$warmups" >&2
+    elapsed=$(request)
+    printf 'Warm-up request %s/%s completed in %ss\n' "$warmup" "$warmups" "$elapsed" >&2
+    warmup=$((warmup + 1))
+done
+
+requestNumber=1
+while [ "$requestNumber" -le "$requests" ]; do
+    printf 'Measured request %s/%s\n' "$requestNumber" "$requests" >&2
+    elapsed=$(request)
+    printf '%s\n' "$elapsed" >>"$resultsFile"
+    printf 'Measured request %s/%s completed in %ss\n' "$requestNumber" "$requests" "$elapsed" >&2
+    requestNumber=$((requestNumber + 1))
+done
+
+sort -n "$resultsFile" | awk '
+    { values[NR] = $1; total += $1 }
+    END {
+        p50 = values[int((NR + 1) * 0.50)]
+        p95 = values[int(NR * 0.95 + 0.999999)]
+        printf "requests=%d min=%.3fs median=%.3fs p95=%.3fs max=%.3fs mean=%.3fs\n", NR, values[1], p50, p95, values[NR], total / NR
+    }
+'
diff --git a/tests/performance/relations/seed-internal-relations.sql b/tests/performance/relations/seed-internal-relations.sql
new file mode 100644
index 00000000000..e7ed035c425
--- /dev/null
+++ b/tests/performance/relations/seed-internal-relations.sql
@@ -0,0 +1,143 @@
+\set ON_ERROR_STOP on
+
+-- Required psql variables:
+--   target_dataset_id, target_version_id, relation_count, relation_type_name
+--
+-- Clones the target dataset's database rows to create released source datasets
+-- and adds one internal relation from each source to the target. This exercises
+-- the incoming-relation and latest-released-version branches of the relation
+-- listing query without thousands of API create/publish calls.
+
+CREATE TEMP TABLE relation_benchmark_sources (
+    dataset_id BIGINT PRIMARY KEY,
+    version_id BIGINT NOT NULL
+);
+
+SELECT set_config('relation_benchmark.target_dataset_id', :'target_dataset_id', false);
+SELECT set_config('relation_benchmark.target_version_id', :'target_version_id', false);
+SELECT set_config('relation_benchmark.relation_count', :'relation_count', false);
+SELECT set_config('relation_benchmark.relation_type_name', :'relation_type_name', false);
+
+DO $$
+DECLARE
+    targetDatasetId BIGINT := current_setting('relation_benchmark.target_dataset_id')::BIGINT;
+    targetVersionId BIGINT := current_setting('relation_benchmark.target_version_id')::BIGINT;
+    relationCount INTEGER := current_setting('relation_benchmark.relation_count')::INTEGER;
+    relationTypeName TEXT := current_setting('relation_benchmark.relation_type_name');
+    relationTypeId BIGINT;
+    inverseRelationTypeId BIGINT;
+    dvobjectSequence TEXT;
+    datasetVersionSequence TEXT;
+    columns TEXT;
+    values TEXT;
+BEGIN
+    IF relationCount < 1 THEN
+        RAISE EXCEPTION 'relation_count must be positive';
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM datasetversion
+        WHERE id = targetVersionId AND dataset_id = targetDatasetId AND versionstate = 'RELEASED'
+    ) THEN
+        RAISE EXCEPTION 'target_version_id must be a released version of target_dataset_id';
+    END IF;
+
+    SELECT id, COALESCE(inverse_id, id)
+    INTO relationTypeId, inverseRelationTypeId
+    FROM datasetrelationtype
+    WHERE name = relationTypeName;
+
+    IF relationTypeId IS NULL THEN
+        RAISE EXCEPTION 'No relation type named % exists', relationTypeName;
+    END IF;
+
+    SELECT pg_get_serial_sequence('dvobject', 'id'), pg_get_serial_sequence('datasetversion', 'id')
+    INTO dvobjectSequence, datasetVersionSequence;
+
+    EXECUTE format(
+        'INSERT INTO relation_benchmark_sources (dataset_id, version_id)
+         SELECT nextval(%L), nextval(%L) FROM generate_series(1, %s)',
+        dvobjectSequence, datasetVersionSequence, relationCount
+    );
+
+    -- Copy all current columns so this keeps working when optional columns are
+    -- added to the entity. Synthetic identifiers are necessary for the DvObject
+    -- unique PID constraint and for relation JSON serialization.
+    SELECT string_agg(format('%I', column_name), ', ' ORDER BY ordinal_position),
+           string_agg(
+               CASE column_name
+                   WHEN 'id' THEN 'source.dataset_id'
+                   WHEN 'identifier' THEN '''benchmark-relation-'' || source.dataset_id'
+                   WHEN 'identifierregistered' THEN 'false'
+                   WHEN 'globalidcreatetime' THEN 'CURRENT_TIMESTAMP'
+                   WHEN 'storageidentifier' THEN 'NULL'
+                   ELSE format('template.%I', column_name)
+               END,
+               ', ' ORDER BY ordinal_position
+           )
+    INTO columns, values
+    FROM information_schema.columns
+    WHERE table_schema = current_schema() AND table_name = 'dvobject';
+    EXECUTE format(
+        'INSERT INTO dvobject (%s) SELECT %s FROM dvobject template
+         CROSS JOIN relation_benchmark_sources source WHERE template.id = %s',
+        columns, values, targetDatasetId
+    );
+
+    SELECT string_agg(format('%I', column_name), ', ' ORDER BY ordinal_position),
+           string_agg(
+               CASE column_name
+                   WHEN 'id' THEN 'source.dataset_id'
+                   WHEN 'harvestidentifier' THEN 'NULL'
+                   WHEN 'harvestingclient_id' THEN 'NULL'
+                   ELSE format('template.%I', column_name)
+               END,
+               ', ' ORDER BY ordinal_position
+           )
+    INTO columns, values
+    FROM information_schema.columns
+    WHERE table_schema = current_schema() AND table_name = 'dataset';
+    EXECUTE format(
+        'INSERT INTO dataset (%s) SELECT %s FROM dataset template
+         CROSS JOIN relation_benchmark_sources source WHERE template.id = %s',
+        columns, values, targetDatasetId
+    );
+
+    -- A copied terms-of-use row may be one-to-one, so leave it unset on each
+    -- synthetic version. It is irrelevant to relation retrieval.
+    SELECT string_agg(format('%I', column_name), ', ' ORDER BY ordinal_position),
+           string_agg(
+               CASE column_name
+                   WHEN 'id' THEN 'source.version_id'
+                   WHEN 'dataset_id' THEN 'source.dataset_id'
+                   WHEN 'termsofuseandaccess_id' THEN 'NULL'
+                   ELSE format('template.%I', column_name)
+               END,
+               ', ' ORDER BY ordinal_position
+           )
+    INTO columns, values
+    FROM information_schema.columns
+    WHERE table_schema = current_schema() AND table_name = 'datasetversion';
+    EXECUTE format(
+        'INSERT INTO datasetversion (%s) SELECT %s FROM datasetversion template
+         CROSS JOIN relation_benchmark_sources source WHERE template.id = %s',
+        columns, values, targetVersionId
+    );
+
+    INSERT INTO datasetrelation (dataset_id, definitionpoint_id, relation_source, relateddataset_id, relationtype_id)
+    SELECT source.dataset_id,
+           source.version_id,
+           'internal',
+           targetDatasetId,
+           relationTypeId
+    FROM relation_benchmark_sources source;
+
+END;
+$$;
+
+ANALYZE dvobject;
+ANALYZE dataset;
+ANALYZE datasetversion;
+ANALYZE datasetrelation;
+
+SELECT COUNT(*) AS seeded_internal_relations FROM relation_benchmark_sources;
diff --git a/tests/performance/relations/seed.sh b/tests/performance/relations/seed.sh
new file mode 100755
index 00000000000..91774740cec
--- /dev/null
+++ b/tests/performance/relations/seed.sh
@@ -0,0 +1,125 @@
+#!/bin/sh
+set -eu
+
+usage() {
+    echo "Usage: $0 -d DATABASE_URL -b BASE_URL -k API_TOKEN [-p PARENT_ALIAS] [-n RELATION_COUNT]" >&2
+    exit 1
+}
+
+databaseUrl=
+baseUrl=
+apiToken=
+parentAlias=root
+relationCount=10000
+suffix="$(date +%s)$$"
+collectionAlias="relationbenchmark${suffix}"
+relationTypeName="isSupplementToBenchmark${suffix}"
+relationTypeInverseName="isSupplementedByBenchmark${suffix}"
+
+while getopts "d:b:k:p:n:" option; do
+    case "$option" in
+        d) databaseUrl=$OPTARG ;;
+        b) baseUrl=$OPTARG ;;
+        k) apiToken=$OPTARG ;;
+        p) parentAlias=$OPTARG ;;
+        n) relationCount=$OPTARG ;;
+        *) usage ;;
+    esac
+done
+
+[ -n "$databaseUrl" ] && [ -n "$baseUrl" ] && [ -n "$apiToken" ] || usage
+
+baseUrl=${baseUrl%/}
+
+apiPost() {
+    description=$1
+    endpoint=$2
+    body=$3
+    responseFile=$(mktemp)
+    printf '%s\n' "$description" >&2
+    if ! statusCode=$(curl --silent --show-error --output "$responseFile" --write-out '%{http_code}' \
+        --header "X-Dataverse-key: $apiToken" \
+        --header 'Content-Type: application/json' \
+        --data "$body" \
+        "$baseUrl$endpoint"); then
+        statusCode=000
+    fi
+    if [ "$statusCode" -lt 200 ] || [ "$statusCode" -ge 300 ]; then
+        printf 'Failed while %s (HTTP %s): %s\n' "$description" "$statusCode" "$baseUrl$endpoint" >&2
+        cat "$responseFile" >&2
+        rm -f "$responseFile"
+        return 1
+    fi
+    cat "$responseFile"
+    rm -f "$responseFile"
+}
+
+apiDatasetRequest() {
+    method=$1
+    description=$2
+    endpoint=$3
+    responseFile=$(mktemp)
+    printf '%s\n' "$description" >&2
+    if ! statusCode=$(curl --silent --show-error --output "$responseFile" --write-out '%{http_code}' \
+        --request "$method" --get \
+        --header "X-Dataverse-key: $apiToken" \
+        --data-urlencode "persistentId=$targetDatasetPid" \
+        "$baseUrl$endpoint"); then
+        statusCode=000
+    fi
+    if [ "$statusCode" -lt 200 ] || [ "$statusCode" -ge 300 ]; then
+        printf 'Failed while %s (HTTP %s): %s\n' "$description" "$statusCode" "$baseUrl$endpoint" >&2
+        cat "$responseFile" >&2
+        rm -f "$responseFile"
+        return 1
+    fi
+    cat "$responseFile"
+    rm -f "$responseFile"
+}
+
+collectionJson=$(printf '{"alias":"%s","name":"Relation benchmark %s","dataverseType":"UNCATEGORIZED","dataverseContacts":[{"contactEmail":"benchmark@example.org"}]}' "$collectionAlias" "$suffix")
+apiPost "Creating temporary collection '$collectionAlias' under '$parentAlias'" "/api/dataverses/$parentAlias" "$collectionJson" >/dev/null
+apiPost "Publishing temporary collection '$collectionAlias'" "/api/dataverses/$collectionAlias/actions/:publish" '' >/dev/null
+
+datasetJson='{"datasetVersion":{"license":{"name":"CC0 1.0","uri":"http://creativecommons.org/publicdomain/zero/1.0"},"metadataBlocks":{"citation":{"fields":[{"typeName":"title","multiple":false,"typeClass":"primitive","value":"Dataset relation benchmark"},{"typeName":"author","multiple":true,"typeClass":"compound","value":[{"authorName":{"typeName":"authorName","multiple":false,"typeClass":"primitive","value":"Benchmark, Relation"}}]},{"typeName":"datasetContact","multiple":true,"typeClass":"compound","value":[{"datasetContactName":{"typeName":"datasetContactName","multiple":false,"typeClass":"primitive","value":"Relation Benchmark"},"datasetContactEmail":{"typeName":"datasetContactEmail","multiple":false,"typeClass":"primitive","value":"benchmark@example.org"}}]},{"typeName":"dsDescription","multiple":true,"typeClass":"compound","value":[{"dsDescriptionValue":{"typeName":"dsDescriptionValue","multiple":false,"typeClass":"primitive","value":"Synthetic dataset for relation-listing benchmarks."}}]},{"typeName":"subject","multiple":true,"typeClass":"controlledVocabulary","value":["Other"]}]}}}}'
+datasetResponse=$(apiPost "Creating benchmark dataset in '$collectionAlias'" "/api/dataverses/$collectionAlias/datasets" "$datasetJson")
+targetDatasetPid=$(printf '%s' "$datasetResponse" | jq -er '.data.persistentId')
+
+apiDatasetRequest POST "Publishing benchmark dataset '$targetDatasetPid'" "/api/datasets/:persistentId/actions/:publish?type=major" >/dev/null
+
+targetDatasetId=
+targetVersionId=
+attempt=1
+while [ "$attempt" -le 60 ]; do
+    datasetResponse=$(apiDatasetRequest GET "Checking publication status for '$targetDatasetPid' (attempt $attempt/60)" "/api/datasets/:persistentId")
+    versionState=$(printf '%s' "$datasetResponse" | jq -r '.data.latestVersion.versionState')
+    if [ "$versionState" = "RELEASED" ]; then
+        targetDatasetId=$(printf '%s' "$datasetResponse" | jq -er '.data.id')
+        targetVersionId=$(printf '%s' "$datasetResponse" | jq -er '.data.latestVersion.id')
+        break
+    fi
+    sleep 1
+    attempt=$((attempt + 1))
+done
+
+[ -n "$targetDatasetId" ] && [ -n "$targetVersionId" ] || {
+    echo "The benchmark dataset was not published within 60 seconds." >&2
+    exit 1
+}
+
+relationTypeJson=$(printf '{"name":"%s","displayName":"Relation benchmark %s","inverse":{"name":"%s","displayName":"Inverse relation benchmark %s"}}' "$relationTypeName" "$suffix" "$relationTypeInverseName" "$suffix")
+apiPost "Creating relation type '$relationTypeName'" "/api/datasets/relationTypes" "$relationTypeJson" >/dev/null
+
+scriptDirectory=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+printf 'Seeding %s incoming internal relations in PostgreSQL\n' "$relationCount" >&2
+psql "$databaseUrl" \
+    -v target_dataset_id="$targetDatasetId" \
+    -v target_version_id="$targetVersionId" \
+    -v relation_count="$relationCount" \
+    -v relation_type_name="$relationTypeName" \
+    -f "$scriptDirectory/seed-internal-relations.sql"
+
+printf 'Seeded %s internal relations for %s (dataset ID %s, version ID %s).\n' \
+    "$relationCount" "$targetDatasetPid" "$targetDatasetId" "$targetVersionId"
+printf 'Measure with: %s/measure-list.sh -b %s -p %s \n' \
+    "$scriptDirectory" "$baseUrl" "$targetDatasetPid"

From 841ccbcfab7bade9663acb26af61da8d0e7cb929 Mon Sep 17 00:00:00 2001
From: Vera Clemens <clemens@zbmed.de>
Date: Fri, 4 Sep 2026 10:54:38 +0200
Subject: [PATCH 2/3] fix: fix issues found after rebasing dataset relations

---
 .../iq/dataverse/api/AbstractApiBean.java     |   2 +-
 .../iq/dataverse/api/DatasetRelations.java    |   6 +-
 .../api/imports/ImportGenericServiceBean.java |   2 +-
 .../api/imports/ImportServiceBean.java        |   2 +-
 .../iq/dataverse/util/json/JsonParser.java    |   2 +-
 .../iq/dataverse/util/json/JsonPrinter.java   |   8 +-
 .../dataverse/api/DatasetRelationTypesIT.java |  31 +-
 .../iq/dataverse/api/DatasetRelationsIT.java  | 285 +++++++++---------
 .../export/SchemaDotOrgExporterTest.java      |   2 +-
 .../dataverse/feedback/FeedbackUtilTest.java  |   6 +-
 .../dataverse/util/json/JsonParserTest.java   |   4 +-
 .../dataverse/util/json/JsonPrinterTest.java  |   2 +-
 12 files changed, 177 insertions(+), 175 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
index 8417f507134..e64eeba9591 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
@@ -282,7 +282,7 @@ public enum Format {
     private final LazyRef<JsonParser> jsonParserRef = new LazyRef<>(new Callable<JsonParser>() {
         @Override
         public JsonParser call() throws Exception {
-            return new JsonParser(datasetFieldSvc, metadataBlockSvc,settingsSvc, licenseSvc, datasetTypeSvc, templateSvc, datasetRelationSvc);
+            return new JsonParser(datasetFieldSvc, metadataBlockSvc,settingsSvc, licenseSvc, datasetTypeSvc, datasetRelationSvc, templateSvc);
         }
     });
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java b/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java
index fad496e8352..49f3ecc4eae 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/DatasetRelations.java
@@ -169,17 +169,17 @@ public Response listRelations(@Context ContainerRequestContext crc, @PathParam("
                         datasetTypeNames, relationSources, effectiveLimit, effectiveOffset);
                 long totalCount = datasetRelationSvc.getTotalDatasetRelationCountFor(dataset, version, relationTypeNames,
                         datasetTypeNames, relationSources);
-                JsonObjectBuilder data = Json.createObjectBuilder()
+                JsonObjectBuilder data = JsonUtil.createObjectBuilder()
                         .add("items", json(relations, dataset, includeMetadataBlocks));
                 if (showFacets) {
-                    data.add("facets", Json.createObjectBuilder()
+                    data.add("facets", JsonUtil.createObjectBuilder()
                             // A facet omits its own filter so clients can offer alternative values.
                             .add("relationType", jsonFacetCounts(datasetRelationSvc.getDatasetRelationFacetCountsFor(dataset, version,
                                     "relationType", null, datasetTypeNames, relationSources)))
                             .add("datasetType", jsonFacetCounts(datasetRelationSvc.getDatasetRelationFacetCountsFor(dataset, version,
                                     "datasetType", relationTypeNames, null, relationSources))));
                 }
-                return Response.ok(Json.createObjectBuilder()
+                return Response.ok(JsonUtil.createObjectBuilder()
                         .add("status", ApiConstants.STATUS_OK)
                         .add("data", data)
                         .add("totalCount", totalCount)
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java
index 30c99fbda0e..fad4b152264 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportGenericServiceBean.java
@@ -116,7 +116,7 @@ public void importXML(String xmlToParse, String foreignFormat, DatasetVersion da
             String json = gson.toJson(datasetDTO.getDatasetVersion());
             logger.fine(json);
             JsonObject obj = JsonUtil.getJsonObject(json);
-            JsonParser parser = new JsonParser(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+            JsonParser parser = new JsonParser(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, datasetRelationService, templateService);
             DatasetVersion dv = parser.parseDatasetVersion(obj, datasetVersion);
             List<DatasetRelation> relations = parser.parseDatasetRelations(obj, dv);
             if (relations != null) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java
index b5a1f8a97c9..242bad5d2f6 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/imports/ImportServiceBean.java
@@ -442,7 +442,7 @@ public JsonObjectBuilder doImport(DataverseRequest dataverseRequest, Dataverse o
         JsonObject obj = JsonUtil.getJsonObject(json);
         //and call parse Json to read it into a dataset   
         try {
-            JsonParser parser = new JsonParser(datasetfieldService, metadataBlockService, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+            JsonParser parser = new JsonParser(datasetfieldService, metadataBlockService, settingsService, licenseService, datasetTypeService, datasetRelationService, templateService);
             parser.setLenient(!importType.equals(ImportType.NEW));
             Dataset ds = parser.parseDataset(obj, owner);
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
index 17dc22dd080..9ed569415f1 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
@@ -69,7 +69,7 @@ public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceB
         this.settingsService = settingsService;
     }
 
-    public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceBean blockService, SettingsServiceBean settingsService, LicenseServiceBean licenseService, DatasetTypeServiceBean datasetTypeService, TemplateServiceBean templateService) {
+    public JsonParser(DatasetFieldServiceBean datasetFieldSvc, MetadataBlockServiceBean blockService, SettingsServiceBean settingsService, LicenseServiceBean licenseService, DatasetTypeServiceBean datasetTypeService, DatasetRelationServiceBean datasetRelationService, TemplateServiceBean templateService) {
         this(datasetFieldSvc, blockService, settingsService, licenseService, datasetTypeService, datasetRelationService, null, templateService);
     }
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
index 51a9db7dc7a..ddd383fdff7 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
@@ -785,7 +785,7 @@ public static JsonObjectBuilder datasetAsJsonForDTO(DatasetVersion dsv, boolean
      * Unit tests for that method could not be found.
      */
     private static JsonObjectBuilder versionAsJsonForDTO(DatasetVersion dsv, boolean includeFiles) {
-        JsonObjectBuilder dsvWithCitation = JsonPrinter.json(dsv, null, includeFiles, false, true, true, false);
+        JsonObjectBuilder dsvWithCitation = JsonPrinter.json(dsv, null, includeFiles, true, false, true, true, false);
         dsvWithCitation.add("citation", dsv.getCitation());
         return dsvWithCitation;
     }
@@ -1190,7 +1190,7 @@ public static JsonObjectBuilder json(DatasetRelation rel, boolean invertRelation
             result.add("datasetPid", dataset.getGlobalId().toString())
                   .add("relatedDatasetPid", relatedDataset.getGlobalId().toString())
                   .add("relatedDatasetType",
-                          Json.createObjectBuilder()
+                          JsonUtil.createObjectBuilder()
                                   .add("name", relatedDataset.getDatasetType().getName())
                                   .add("displayName", relatedDataset.getDatasetType().getDisplayName()));
 
@@ -1198,7 +1198,7 @@ public static JsonObjectBuilder json(DatasetRelation rel, boolean invertRelation
                 DatasetVersion releasedVersion = relatedDataset.getReleasedVersion();
                 if (releasedVersion != null) {
                     result.add("relatedDataset",
-                            Json.createObjectBuilder().add("metadataBlocks", jsonByBlocks(releasedVersion.getDatasetFields()))
+                            JsonUtil.createObjectBuilder().add("metadataBlocks", jsonByBlocks(releasedVersion.getDatasetFields()))
                     );
                 }
             }
@@ -1210,7 +1210,7 @@ public static JsonObjectBuilder json(DatasetRelation rel, boolean invertRelation
 
             if (erel.getDatasetType() != null) {
                   result.add("relatedDatasetType",
-                        Json.createObjectBuilder().add("displayName", erel.getDatasetType()));
+                        JsonUtil.createObjectBuilder().add("displayName", erel.getDatasetType()));
             }
         }
 
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java
index b76fbc3579d..92ecbce96ae 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationTypesIT.java
@@ -1,5 +1,6 @@
 package edu.harvard.iq.dataverse.api;
 
+import edu.harvard.iq.dataverse.util.json.JsonUtil;
 import io.restassured.RestAssured;
 import io.restassured.response.Response;
 import jakarta.json.Json;
@@ -41,7 +42,7 @@ public void testRelationTypeCRUD() {
         String description = "Test description";
 
         // Create relation type without inverse
-        JsonObjectBuilder builder = Json.createObjectBuilder()
+        JsonObjectBuilder builder = JsonUtil.createObjectBuilder()
                 .add("name", name)
                 .add("displayName", displayName)
                 .add("description", description);
@@ -69,11 +70,11 @@ public void testRelationTypeCRUD() {
         String description2 = "Test description2";
 
         // Create relation type which is inverse of itself
-        JsonObjectBuilder builder2 = Json.createObjectBuilder()
+        JsonObjectBuilder builder2 = JsonUtil.createObjectBuilder()
                 .add("name", name2)
                 .add("displayName", displayName2)
                 .add("description", description2)
-                .add("inverse", Json.createObjectBuilder().add("name", name2));
+                .add("inverse", JsonUtil.createObjectBuilder().add("name", name2));
 
         UtilIT.addDatasetRelationType(builder2.build().toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
@@ -96,11 +97,11 @@ public void testRelationTypeCRUD() {
         String inverseDescription3 = "Test inverse description3";
 
         // Create relation type with an inverse relation type
-        JsonObjectBuilder builder3 = Json.createObjectBuilder()
+        JsonObjectBuilder builder3 = JsonUtil.createObjectBuilder()
                 .add("name", name3)
                 .add("displayName", displayName3)
                 .add("description", description3)
-                .add("inverse", Json.createObjectBuilder().add("name", inverseName3)
+                .add("inverse", JsonUtil.createObjectBuilder().add("name", inverseName3)
                                                                  .add("displayName", inverseDisplayName3)
                                                                  .add("description", inverseDescription3));
 
@@ -171,19 +172,19 @@ public void testRelationTypeCRUD() {
     @Test
     public void testCreateRelationTypeValidation() {
         // Missing name
-        JsonObjectBuilder noName = Json.createObjectBuilder()
+        JsonObjectBuilder noName = JsonUtil.createObjectBuilder()
                 .add("displayName", "No Name");
         UtilIT.addDatasetRelationType(noName.build().toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
 
         // Missing displayName
-        JsonObjectBuilder noDisplayName = Json.createObjectBuilder()
+        JsonObjectBuilder noDisplayName = JsonUtil.createObjectBuilder()
                 .add("name", "noDisplayName");
         UtilIT.addDatasetRelationType(noDisplayName.build().toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
         
         // Empty name
-        JsonObjectBuilder emptyName = Json.createObjectBuilder()
+        JsonObjectBuilder emptyName = JsonUtil.createObjectBuilder()
                 .add("name", "")
                 .add("displayName", "Empty Name");
         UtilIT.addDatasetRelationType(emptyName.build().toString(), apiTokenSuperuser)
@@ -193,7 +194,7 @@ public void testCreateRelationTypeValidation() {
     @Test
     public void testRelationTypePermissions() {
         String name = "permTest" + UtilIT.getRandomString(6);
-        JsonObjectBuilder builder = Json.createObjectBuilder()
+        JsonObjectBuilder builder = JsonUtil.createObjectBuilder()
                 .add("name", name)
                 .add("displayName", "Perm Test" + UtilIT.getRandomString(6));
         String jsonIn = builder.build().toString();
@@ -207,7 +208,7 @@ public void testRelationTypePermissions() {
                 .then().assertThat().statusCode(OK.getStatusCode());
 
         String defaultName = "permDefault" + UtilIT.getRandomString(6);
-        UtilIT.addDatasetRelationType(Json.createObjectBuilder()
+        UtilIT.addDatasetRelationType(JsonUtil.createObjectBuilder()
                         .add("name", defaultName)
                         .add("displayName", "Perm Default " + UtilIT.getRandomString(6))
                         .build().toString(), apiTokenSuperuser)
@@ -230,7 +231,7 @@ public void testRelationTypePermissions() {
     @Test
     public void testDeleteRelationTypeFailureWhenInUse() {
         String typeName = "inUseTest" + UtilIT.getRandomString(6);
-        JsonObjectBuilder builder = Json.createObjectBuilder()
+        JsonObjectBuilder builder = JsonUtil.createObjectBuilder()
                 .add("name", typeName)
                 .add("displayName", "In Use Test" + UtilIT.getRandomString(6));
 
@@ -246,9 +247,9 @@ public void testDeleteRelationTypeFailureWhenInUse() {
         Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
 
-        String relationJson = Json.createObjectBuilder()
+        String relationJson = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", typeName))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", typeName))
                 .build().toString();
 
         UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser)
@@ -262,11 +263,11 @@ public void testDeleteRelationTypeFailureWhenInUse() {
         // Cleanup: remove relation first
         // Need the relation ID
         Response listResponse = UtilIT.listDatasetRelations(pidA, apiTokenSuperuser);
-        int relationId = listResponse.jsonPath().getInt("data[0].id");
+        int relationId = listResponse.jsonPath().getInt("data.items[0].id");
         UtilIT.deleteDatasetRelation(pidA, relationId, apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
 
         String defaultName = "defaultAfterInUse" + UtilIT.getRandomString(6);
-        UtilIT.addDatasetRelationType(Json.createObjectBuilder()
+        UtilIT.addDatasetRelationType(JsonUtil.createObjectBuilder()
                         .add("name", defaultName)
                         .add("displayName", "Default After In Use " + UtilIT.getRandomString(6))
                         .build().toString(), apiTokenSuperuser)
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java
index 8275c22226c..d3c5f0ab073 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DatasetRelationsIT.java
@@ -1,6 +1,7 @@
 package edu.harvard.iq.dataverse.api;
 
 import edu.harvard.iq.dataverse.authorization.DataverseRole;
+import edu.harvard.iq.dataverse.util.json.JsonUtil;
 import io.restassured.RestAssured;
 import io.restassured.path.json.JsonPath;
 import io.restassured.response.Response;
@@ -39,28 +40,28 @@ public static void setUpClass() {
         UtilIT.setSuperuserStatus(usernameSuperuser, true).then().assertThat().statusCode(OK.getStatusCode());
 
         // Ensure relation types exist
-        String relationTypeJson = Json.createObjectBuilder()
+        String relationTypeJson = JsonUtil.createObjectBuilder()
                 .add("name", "isRelatedTo")
                 .add("displayName", "Is related to")
-                .add("inverse", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                .add("inverse", JsonUtil.createObjectBuilder().add("name", "isRelatedTo"))
                 .build().toString();
         UtilIT.addDatasetRelationType(relationTypeJson, apiTokenSuperuser);
         
-        String relationTypeJson2 = Json.createObjectBuilder()
+        String relationTypeJson2 = JsonUtil.createObjectBuilder()
                 .add("name", "isSupplementTo")
                 .add("displayName", "Is supplement to")
-                .add("inverse", Json.createObjectBuilder().add("name", "isSupplementedBy").add("displayName", "Is supplemented by"))
+                .add("inverse", JsonUtil.createObjectBuilder().add("name", "isSupplementedBy").add("displayName", "Is supplemented by"))
                 .build().toString();
         UtilIT.addDatasetRelationType(relationTypeJson2, apiTokenSuperuser);
 
-        String relationTypeJson3 = Json.createObjectBuilder()
+        String relationTypeJson3 = JsonUtil.createObjectBuilder()
                 .add("name", "isCitedBy")
                 .add("displayName", "Is cited by")
-                .add("inverse", Json.createObjectBuilder().add("name", "cites").add("displayName", "Cites"))
+                .add("inverse", JsonUtil.createObjectBuilder().add("name", "cites").add("displayName", "Cites"))
                 .build().toString();
         UtilIT.addDatasetRelationType(relationTypeJson3, apiTokenSuperuser);
 
-        String relationTypeWithoutInverseJson = Json.createObjectBuilder()
+        String relationTypeWithoutInverseJson = JsonUtil.createObjectBuilder()
                 .add("name", "isDerivedFromWithoutInverse")
                 .add("displayName", "Is derived from without inverse")
                 .build().toString();
@@ -89,10 +90,10 @@ public void testListDatasetRelationsFilteringByRelationTypeAndVersion() {
 
         // Version 1.0 of Dataset A:
         // Relation 1: A -> B (isRelatedTo)
-        JsonArray relationsV1 = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relationsV1 = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relationsV1.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
         UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
@@ -101,16 +102,16 @@ public void testListDatasetRelationsFilteringByRelationTypeAndVersion() {
         // Relation 1: A -> B (isRelatedTo) - kept from V1
         // Relation 2: A -> B (isSupplementTo)
         // Relation 2: A -> C (isSupplementTo)
-        JsonArray relationsV2 = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relationsV2 = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidC)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo")))
                 .build();
         // This will create a draft for v2.0
         UtilIT.replaceDatasetRelations(pidA, relationsV2.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
@@ -188,7 +189,7 @@ public void testListDatasetRelationsFilteringByDatasetType() {
         Response getDatasetType = UtilIT.getDatasetType("software");
         String typeFound = JsonPath.from(getDatasetType.getBody().asString()).getString("data.name");
         if (!("software".equals(typeFound))) {
-            JsonObject softwareTypeJson = Json.createObjectBuilder()
+            JsonObject softwareTypeJson = JsonUtil.createObjectBuilder()
                     .add("name", "software")
                     .add("displayName", "Software")
                     .add("description", "Software Dataset Type")
@@ -215,18 +216,18 @@ public void testListDatasetRelationsFilteringByDatasetType() {
         String pidC = UtilIT.getDatasetPersistentIdFromResponse(createDatasetC);
 
         // Create relations: A -> B (isRelatedTo), A -> C (isRelatedTo), A -> External (isRelatedTo)
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidC)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("externalIdentifier", "doi:10.1234/external")
                         .add("identifierScheme", "DOI")
                         .add("datasetType", "Software")
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo"))
                         .add("relationSource", "external"))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
@@ -292,14 +293,14 @@ public void testListDatasetRelationsFilteringBySource() {
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
 
         // Create 1 internal and 1 external relation
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("externalIdentifier", "https://example.org/1")
                         .add("identifierScheme", "URL")
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
 
@@ -350,20 +351,20 @@ public void testListDatasetRelationsOrdering() {
         String pidC = UtilIT.getDatasetPersistentIdFromResponse(createDatasetC);
 
         // Define relation B -> A (defined on B)
-        JsonArray relationsB = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relationsB = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidA)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
         UtilIT.replaceDatasetRelations(pidB, relationsB.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
         UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
 
         // Define relation A -> C (defined on A)
-        JsonArray relationsA = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relationsA = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidC)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relationsA.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
@@ -406,10 +407,10 @@ public void testListDatasetRelationDeduplication() {
                 .body("data.items[0].relatedDatasetCount", equalTo(0));
 
         // Define relation A (draft) -> B
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isCitedBy")))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
@@ -424,10 +425,10 @@ public void testListDatasetRelationDeduplication() {
                 .body("data.items[0].relatedDatasetCount", equalTo(1));
 
         // Define the SAME relation in inverse direction: B (draft) -> A
-        JsonArray relationsInverse = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relationsInverse = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidA)
-                        .add("relationType", Json.createObjectBuilder().add("name", "cites")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "cites")))
                 .build();
         UtilIT.replaceDatasetRelations(pidB, relationsInverse.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
@@ -438,10 +439,10 @@ public void testListDatasetRelationDeduplication() {
         // Create A v2 (draft) and add one more relation
         // (The existing relation from A v1 still exists)
         String externalUrl = "https://example.org/dataset/12345";
-        JsonObject relationNew = Json.createObjectBuilder()
+        JsonObject relationNew = JsonUtil.createObjectBuilder()
                 .add("externalIdentifier", externalUrl)
                 .add("identifierScheme", "URL")
-                .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo"))
                 .build();
         UtilIT.addDatasetRelation(pidA, relationNew.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
@@ -481,10 +482,10 @@ public void testListDatasetRelationsVersionIsolation() {
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
 
         // Add relation from Dataset B (draft) to Dataset A (v1.0) at dataset B (draft)
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidA)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
 
         UtilIT.replaceDatasetRelations(pidB, relations.toString(), apiTokenSuperuser)
@@ -592,11 +593,11 @@ public void testListExternalDatasetRelations() {
 
         // Add external relation to Dataset A (draft)
         String externalUrl = "https://example.org/dataset/12345";
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("externalIdentifier", externalUrl)
                         .add("identifierScheme", "URL")
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
 
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
@@ -613,12 +614,12 @@ public void testListExternalDatasetRelations() {
 
         // Add external relation with datasetType
         String externalUrlWithDocType = "https://example.org/dataset/67890";
-        JsonArray relationsWithDocType = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relationsWithDocType = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("externalIdentifier", externalUrlWithDocType)
                         .add("identifierScheme", "URL")
-                        .add("relatedDatasetType", Json.createObjectBuilder().add("displayName", "Document"))
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relatedDatasetType", JsonUtil.createObjectBuilder().add("displayName", "Document"))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
 
         UtilIT.replaceDatasetRelations(pidA, relationsWithDocType.toString(), apiTokenSuperuser)
@@ -649,15 +650,15 @@ public void testListExternalDatasetRelations() {
         Response createDatasetB = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser);
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
 
-        JsonArray mixedRelations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray mixedRelations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("externalIdentifier", "doi:10.1234/5678")
                         .add("identifierScheme", "DOI")
-                        .add("relatedDatasetType", Json.createObjectBuilder().add("displayName", "Dataset"))
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relatedDatasetType", JsonUtil.createObjectBuilder().add("displayName", "Dataset"))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
 
         UtilIT.replaceDatasetRelations(pidA, mixedRelations.toString(), apiTokenSuperuser)
@@ -700,10 +701,10 @@ public void testDestroyDatasetRemovesIncomingRelations() {
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(createDatasetB);
         int idB = UtilIT.getDatasetIdFromResponse(createDatasetB);
 
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
@@ -730,9 +731,9 @@ public void testInternalRelationsWithoutInverseType() {
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
 
         // Create relation A -> B using a relation type that has no inverse
-        JsonObject relation = Json.createObjectBuilder()
+        JsonObject relation = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "isDerivedFromWithoutInverse"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isDerivedFromWithoutInverse"))
                 .build();
         Response createRelation = UtilIT.addDatasetRelation(pidA, relation.toString(), apiTokenSuperuser);
         createRelation.then().assertThat().statusCode(OK.getStatusCode());
@@ -793,15 +794,15 @@ public void testGetDatasetRelationCounts() {
         // 2. isRelatedTo (count: 3)
         // 3. isSupplementTo (count: 2)
 
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[0]).add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[1]).add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[2]).add("relationType", Json.createObjectBuilder().add("name", "isCitedBy")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[3]).add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[4]).add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[5]).add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[6]).add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo")))
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", pids[7]))
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[0]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isCitedBy")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[1]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isCitedBy")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[2]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isCitedBy")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[3]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[4]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[5]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[6]).add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo")))
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", pids[7]))
                 .build();
 
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
@@ -851,9 +852,9 @@ public void testDatasetRelationCRUD() {
         UtilIT.publishDatasetViaNativeApi(pidB, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
 
         // POST /api/datasets/{identifier}/relations
-        String relationJson = Json.createObjectBuilder()
+        String relationJson = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo"))
                 .build().toString();
 
         Response postResponse = UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser);
@@ -875,7 +876,7 @@ public void testDatasetRelationCRUD() {
                 .body("data.relationType.name", equalTo("isSupplementedBy"));
 
         // POST /api/datasets/{identifier}/relations
-        relationJson = Json.createObjectBuilder()
+        relationJson = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
                 .build().toString();
 
@@ -924,9 +925,9 @@ public void testDatasetRelationCRUDErrorPaths() {
                 .then().assertThat().statusCode(NOT_FOUND.getStatusCode());
 
         // First create a relation
-        String relationJson = Json.createObjectBuilder()
+        String relationJson = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo"))
                 .build().toString();
 
         long relationId = UtilIT.addDatasetRelation(pidA, relationJson, apiTokenSuperuser)
@@ -934,9 +935,9 @@ public void testDatasetRelationCRUDErrorPaths() {
 
         // Try to create relation with non-existent relation type
         // Should be 400
-        String invalidRelationJson = Json.createObjectBuilder()
+        String invalidRelationJson = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "iDontExist"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "iDontExist"))
                 .build().toString();
 
         UtilIT.addDatasetRelation(pidA, invalidRelationJson.toString(), apiTokenSuperuser)
@@ -953,9 +954,9 @@ public void testDatasetRelationCRUDErrorPaths() {
 
         // Try to add the already existing relation to B again
         // Should count as a duplicate and therefore be 400
-        JsonObject dupRelation = Json.createObjectBuilder()
+        JsonObject dupRelation = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo"))
                 .build();
 
         UtilIT.addDatasetRelation(pidA, dupRelation.toString(), apiTokenSuperuser)
@@ -992,9 +993,9 @@ public void testDatasetRelationCRUDAuthErrorPaths() {
         String apiTokenUser = UtilIT.getApiTokenFromResponse(createUser);
 
         // Without edit rights on the dataset, post and delete should fail
-        String relationJson = Json.createObjectBuilder()
+        String relationJson = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo"))
                 .build().toString();
 
         UtilIT.addDatasetRelation(pidA, relationJson, apiTokenUser)
@@ -1036,41 +1037,41 @@ public void testReplaceDatasetRelationsErrorPaths() {
         String pidA = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
         String pidB = UtilIT.getDatasetPersistentIdFromResponse(UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiTokenSuperuser));
 
-        JsonObject typedRelation = Json.createObjectBuilder()
+        JsonObject typedRelation = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo"))
                 .build();
-        UtilIT.replaceDatasetRelations(pidA, Json.createArrayBuilder().add(typedRelation).build().toString(), apiTokenSuperuser)
+        UtilIT.replaceDatasetRelations(pidA, JsonUtil.createArrayBuilder().add(typedRelation).build().toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
 
-        JsonObject untypedRelation = Json.createObjectBuilder()
+        JsonObject untypedRelation = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
                 .build();
-        JsonArray typedThenUntyped = Json.createArrayBuilder()
+        JsonArray typedThenUntyped = JsonUtil.createArrayBuilder()
                 .add(typedRelation)
                 .add(untypedRelation)
                 .build();
         UtilIT.replaceDatasetRelations(pidA, typedThenUntyped.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
 
-        JsonArray untypedThenTyped = Json.createArrayBuilder()
+        JsonArray untypedThenTyped = JsonUtil.createArrayBuilder()
                 .add(untypedRelation)
                 .add(typedRelation)
                 .build();
         UtilIT.replaceDatasetRelations(pidA, untypedThenTyped.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
 
-        JsonArray invalidRelatedDataset = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder().add("relatedDatasetPid", "doi:10.5072/FK2/DOESNOTEXIST"))
+        JsonArray invalidRelatedDataset = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder().add("relatedDatasetPid", "doi:10.5072/FK2/DOESNOTEXIST"))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, invalidRelatedDataset.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
 
-        JsonObject invalidRelationType = Json.createObjectBuilder()
+        JsonObject invalidRelationType = JsonUtil.createObjectBuilder()
                 .add("relatedDatasetPid", pidB)
-                .add("relationType", Json.createObjectBuilder().add("name", "iDontExist"))
+                .add("relationType", JsonUtil.createObjectBuilder().add("name", "iDontExist"))
                 .build();
-        UtilIT.replaceDatasetRelations(pidA, Json.createArrayBuilder().add(invalidRelationType).build().toString(), apiTokenSuperuser)
+        UtilIT.replaceDatasetRelations(pidA, JsonUtil.createArrayBuilder().add(invalidRelationType).build().toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
 
         UtilIT.listDatasetRelations(pidA, apiTokenSuperuser)
@@ -1087,62 +1088,62 @@ public void testDatasetRelationsViaVersionApis() {
 
         // Create dataset with relations via POST api/dataverses/%s/datasets
         String externalUrl1 = "https://example.org/dataset/1";
-        JsonObject datasetData = Json.createObjectBuilder()
-                .add("datasetVersion", Json.createObjectBuilder()
-                        .add("license", Json.createObjectBuilder()
+        JsonObject datasetData = JsonUtil.createObjectBuilder()
+                .add("datasetVersion", JsonUtil.createObjectBuilder()
+                        .add("license", JsonUtil.createObjectBuilder()
                                 .add("name", "CC0 1.0")
                                 .add("uri", "http://creativecommons.org/publicdomain/zero/1.0"))
-                        .add("metadataBlocks", Json.createObjectBuilder()
-                                .add("citation", Json.createObjectBuilder()
-                                        .add("fields", Json.createArrayBuilder()
-                                                .add(Json.createObjectBuilder()
+                        .add("metadataBlocks", JsonUtil.createObjectBuilder()
+                                .add("citation", JsonUtil.createObjectBuilder()
+                                        .add("fields", JsonUtil.createArrayBuilder()
+                                                .add(JsonUtil.createObjectBuilder()
                                                         .add("typeName", "title")
                                                         .add("multiple", false)
                                                         .add("typeClass", "primitive")
                                                         .add("value", "Dataset with Relations"))
-                                                .add(Json.createObjectBuilder()
+                                                .add(JsonUtil.createObjectBuilder()
                                                         .add("typeName", "author")
                                                         .add("multiple", true)
                                                         .add("typeClass", "compound")
-                                                        .add("value", Json.createArrayBuilder()
-                                                                .add(Json.createObjectBuilder()
-                                                                        .add("authorName", Json.createObjectBuilder()
+                                                        .add("value", JsonUtil.createArrayBuilder()
+                                                                .add(JsonUtil.createObjectBuilder()
+                                                                        .add("authorName", JsonUtil.createObjectBuilder()
                                                                                 .add("typeName", "authorName")
                                                                                 .add("multiple", false)
                                                                                 .add("typeClass", "primitive")
                                                                                 .add("value", "Lastname, Firstname")))))
-                                                .add(Json.createObjectBuilder()
+                                                .add(JsonUtil.createObjectBuilder()
                                                         .add("typeName", "datasetContact")
                                                         .add("multiple", true)
                                                         .add("typeClass", "compound")
-                                                        .add("value", Json.createArrayBuilder()
-                                                                .add(Json.createObjectBuilder()
-                                                                        .add("datasetContactEmail", Json.createObjectBuilder()
+                                                        .add("value", JsonUtil.createArrayBuilder()
+                                                                .add(JsonUtil.createObjectBuilder()
+                                                                        .add("datasetContactEmail", JsonUtil.createObjectBuilder()
                                                                                 .add("typeName", "datasetContactEmail")
                                                                                 .add("multiple", false)
                                                                                 .add("typeClass", "primitive")
                                                                                 .add("value", "test@example.edu")))))
-                                                .add(Json.createObjectBuilder()
+                                                .add(JsonUtil.createObjectBuilder()
                                                         .add("typeName", "dsDescription")
                                                         .add("multiple", true)
                                                         .add("typeClass", "compound")
-                                                        .add("value", Json.createArrayBuilder()
-                                                                .add(Json.createObjectBuilder()
-                                                                        .add("dsDescriptionValue", Json.createObjectBuilder()
+                                                        .add("value", JsonUtil.createArrayBuilder()
+                                                                .add(JsonUtil.createObjectBuilder()
+                                                                        .add("dsDescriptionValue", JsonUtil.createObjectBuilder()
                                                                                 .add("typeName", "dsDescriptionValue")
                                                                                 .add("multiple", false)
                                                                                 .add("typeClass", "primitive")
                                                                                 .add("value", "Description text")))))
-                                                .add(Json.createObjectBuilder()
+                                                .add(JsonUtil.createObjectBuilder()
                                                         .add("typeName", "subject")
                                                         .add("multiple", true)
                                                         .add("typeClass", "controlledVocabulary")
-                                                        .add("value", Json.createArrayBuilder().add("Agricultural Sciences"))))))
-                        .add("relations", Json.createArrayBuilder()
-                                .add(Json.createObjectBuilder()
+                                                        .add("value", JsonUtil.createArrayBuilder().add("Agricultural Sciences"))))))
+                        .add("relations", JsonUtil.createArrayBuilder()
+                                .add(JsonUtil.createObjectBuilder()
                                         .add("externalIdentifier", externalUrl1)
                                         .add("identifierScheme", "URL")
-                                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))))
+                                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))))
                 .build();
 
         Response createDataset = UtilIT.createDataset(dataverseAlias, datasetData.toString(), apiTokenSuperuser);
@@ -1171,12 +1172,12 @@ public void testDatasetRelationsViaVersionApis() {
         String externalUrl2 = "https://example.org/dataset/2";
 
         // Reuse the existing data and replace relations
-        JsonObject updatedVersionData = Json.createObjectBuilder(datasetData.getJsonObject("datasetVersion"))
-                .add("relations", Json.createArrayBuilder()
-                        .add(Json.createObjectBuilder()
+        JsonObject updatedVersionData = JsonUtil.createObjectBuilder(datasetData.getJsonObject("datasetVersion"))
+                .add("relations", JsonUtil.createArrayBuilder()
+                        .add(JsonUtil.createObjectBuilder()
                                 .add("externalIdentifier", externalUrl2)
                                 .add("identifierScheme", "URL")
-                                .add("relationType", Json.createObjectBuilder().add("name", "isSupplementTo"))))
+                                .add("relationType", JsonUtil.createObjectBuilder().add("name", "isSupplementTo"))))
                 .build();
 
         UtilIT.updateDatasetMetadataViaNative(pid, updatedVersionData, apiTokenSuperuser)
@@ -1188,38 +1189,38 @@ public void testDatasetRelationsViaVersionApis() {
 
         // Try to upload invalid relations
         // Should be 400
-        JsonObject unknownRelationTypeVersion = Json.createObjectBuilder(updatedVersionData)
-                .add("relations", Json.createArrayBuilder()
-                        .add(Json.createObjectBuilder()
+        JsonObject unknownRelationTypeVersion = JsonUtil.createObjectBuilder(updatedVersionData)
+                .add("relations", JsonUtil.createArrayBuilder()
+                        .add(JsonUtil.createObjectBuilder()
                                 .add("externalIdentifier", externalUrl2)
                                 .add("identifierScheme", "URL")
-                                .add("relationType", Json.createObjectBuilder().add("name", "unknownRelationType"))))
+                                .add("relationType", JsonUtil.createObjectBuilder().add("name", "unknownRelationType"))))
                 .build();
         UtilIT.updateDatasetMetadataViaNative(pid, unknownRelationTypeVersion, apiTokenSuperuser)
                 .then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
 
-        JsonObject unknownRelatedDatasetVersion = Json.createObjectBuilder(updatedVersionData)
-                .add("relations", Json.createArrayBuilder()
-                        .add(Json.createObjectBuilder()
+        JsonObject unknownRelatedDatasetVersion = JsonUtil.createObjectBuilder(updatedVersionData)
+                .add("relations", JsonUtil.createArrayBuilder()
+                        .add(JsonUtil.createObjectBuilder()
                                 .add("relatedDatasetPid", "doi:10.5072/FK2/DOESNOTEXIST")))
                 .build();
 
         // Change metadata in the same request as the invalid relation
         // The entire update should roll back
         JsonObject citation = updatedVersionData.getJsonObject("metadataBlocks").getJsonObject("citation");
-        jakarta.json.JsonArrayBuilder changedFields = Json.createArrayBuilder();
+        jakarta.json.JsonArrayBuilder changedFields = JsonUtil.createArrayBuilder();
         for (JsonValue fieldValue : citation.getJsonArray("fields")) {
             JsonObject field = (JsonObject) fieldValue;
             if ("title".equals(field.getString("typeName"))) {
-                changedFields.add(Json.createObjectBuilder(field).add("value", "This title must not persist"));
+                changedFields.add(JsonUtil.createObjectBuilder(field).add("value", "This title must not persist"));
             } else {
                 changedFields.add(field);
             }
         }
-        JsonObject changedMetadataBlocks = Json.createObjectBuilder(updatedVersionData.getJsonObject("metadataBlocks"))
-                .add("citation", Json.createObjectBuilder(citation).add("fields", changedFields))
+        JsonObject changedMetadataBlocks = JsonUtil.createObjectBuilder(updatedVersionData.getJsonObject("metadataBlocks"))
+                .add("citation", JsonUtil.createObjectBuilder(citation).add("fields", changedFields))
                 .build();
-        JsonObject invalidRelationAndMetadata = Json.createObjectBuilder(unknownRelatedDatasetVersion)
+        JsonObject invalidRelationAndMetadata = JsonUtil.createObjectBuilder(unknownRelatedDatasetVersion)
                 .add("metadataBlocks", changedMetadataBlocks)
                 .build();
         UtilIT.updateDatasetMetadataViaNative(pid, invalidRelationAndMetadata, apiTokenSuperuser)
@@ -1236,7 +1237,7 @@ public void testDatasetRelationsViaVersionApis() {
         UtilIT.publishDatasetViaNativeApi(pid, "major", apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
 
-        JsonObject versionWithoutRelations = Json.createObjectBuilder(updatedVersionData)
+        JsonObject versionWithoutRelations = JsonUtil.createObjectBuilder(updatedVersionData)
                 .remove("relations")
                 .build();
         UtilIT.updateDatasetMetadataViaNative(pid, versionWithoutRelations, apiTokenSuperuser)
@@ -1267,14 +1268,14 @@ public void testVersionSummariesIncludeRelationChanges() {
 
         UtilIT.publishDatasetViaNativeApi(pidA, "major", apiTokenSuperuser).then().assertThat().statusCode(OK.getStatusCode());
 
-        JsonArray relations = Json.createArrayBuilder()
-                .add(Json.createObjectBuilder()
+        JsonArray relations = JsonUtil.createArrayBuilder()
+                .add(JsonUtil.createObjectBuilder()
                         .add("relatedDatasetPid", pidB)
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
-                .add(Json.createObjectBuilder()
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
+                .add(JsonUtil.createObjectBuilder()
                         .add("externalIdentifier", externalIdentifier)
                         .add("identifierScheme", "URL")
-                        .add("relationType", Json.createObjectBuilder().add("name", "isRelatedTo")))
+                        .add("relationType", JsonUtil.createObjectBuilder().add("name", "isRelatedTo")))
                 .build();
         UtilIT.replaceDatasetRelations(pidA, relations.toString(), apiTokenSuperuser)
                 .then().assertThat().statusCode(OK.getStatusCode());
diff --git a/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java b/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java
index 22600fc8b38..bf490260770 100644
--- a/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/export/SchemaDotOrgExporterTest.java
@@ -187,7 +187,7 @@ public void testExportWithoutDownloadUrl() throws IOException, JsonParseExceptio
     private JsonObject createExportFromJson(ExportDataProvider provider) throws JsonParseException, ParseException {
         License license = new License("CC0 1.0", "You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.", URI.create("http://creativecommons.org/publicdomain/zero/1.0/"), URI.create("/resources/images/cc0.png"), true, 1l);
         license.setDefault(true);
-        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, datasetRelationService, templateService);
         DatasetVersion version = jsonParser.parseDatasetVersion(provider.getDatasetJson().getJsonObject("datasetVersion"));
         version.setVersionState(DatasetVersion.VersionState.RELEASED);
         SimpleDateFormat dateFmt = new SimpleDateFormat("yyyyMMdd");
diff --git a/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java b/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java
index 8a0de794879..8010fe49c77 100644
--- a/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/feedback/FeedbackUtilTest.java
@@ -133,16 +133,16 @@ public static void setUpClass() throws IOException, JsonParseException, AddressE
 
         JsonObject json1 = JsonUtil.getJsonObjectFromFile("src/test/resources/json/dataset-finch1.json");
 
-        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, datasetRelationService, templateService);
         dsVersion = jsonParser.parseDatasetVersion(json1.getJsonObject("datasetVersion"));
 
         JsonObject json12 = JsonUtil.getJsonObjectFromFile("tests/data/datasetContacts1.json");
 
-        JsonParser jsonParser2 = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+        JsonParser jsonParser2 = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, datasetRelationService, templateService);
         dsVersion2 = jsonParser2.parseDatasetVersion(json12.getJsonObject("datasetVersion"));
 
         JsonObject jsonNoContacts = JsonUtil.getJsonObjectFromFile("tests/data/datasetNoContacts.json");
-        JsonParser jsonParserNoContacts = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, templateService, datasetRelationService);
+        JsonParser jsonParserNoContacts = new JsonParser(datasetFieldTypeSvc, null, settingsService, licenseService, datasetTypeService, datasetRelationService, templateService);
         dsVersionNoContacts = jsonParserNoContacts.parseDatasetVersion(jsonNoContacts.getJsonObject("datasetVersion"));
 
         FeedbackUtil justForCodeCoverage = new FeedbackUtil();
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
index 676f1ad32e0..583b9afe389 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
@@ -176,7 +176,7 @@ public void setUp() {
         datasetType.setName(DatasetType.DEFAULT_DATASET_TYPE);
         datasetType.setId(1l);
         Mockito.when(datasetTypeService.getByName(DatasetType.DEFAULT_DATASET_TYPE)).thenReturn(datasetType);
-        sut = new JsonParser(datasetFieldTypeSvc, null, settingsSvc, licenseService, datasetTypeService, templateService, datasetRelationService);
+        sut = new JsonParser(datasetFieldTypeSvc, null, settingsSvc, licenseService, datasetTypeService, datasetRelationService, templateService);
     }
     
     @Test 
@@ -987,7 +987,7 @@ public void testDatasetVersionJsonPrinterJsonParser() throws JsonParseException
         datasetType.setName(DatasetType.DEFAULT_DATASET_TYPE);
         datasetType.setId(1l);
         Mockito.when(datasetTypeService.getByName(DatasetType.DEFAULT_DATASET_TYPE)).thenReturn(datasetType);
-        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsSvc, licenseService, datasetTypeService, templateService);
+        JsonParser jsonParser = new JsonParser(datasetFieldTypeSvc, null, settingsSvc, licenseService, datasetTypeService, datasetRelationService, templateService);
 
         Dataset ds = new Dataset();
         DatasetVersion dsv1 = new DatasetVersion();
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
index e46db5f2adb..5d5b5b395be 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
@@ -558,7 +558,7 @@ public void testDatasetWithGuestbook() {
         dataset.setGuestbook(guestbook);
 
         // verify that the guestbook id is in the dataset response
-        var jsob = JsonPrinter.json(dataset.getLatestVersion(), null, false, false, false, false, false).build();
+        var jsob = JsonPrinter.json(dataset.getLatestVersion(), null, false, false, false, false, false, false).build();
         System.out.println(jsob);
         var gbID = jsob.getInt("guestbookId");
         assertEquals(1, gbID);

From 79a74d77d22b2ac4e61a4e396da3ebb11edc94ed Mon Sep 17 00:00:00 2001
From: Vera Clemens <clemens@zbmed.de>
Date: Fri, 4 Sep 2026 12:16:40 +0200
Subject: [PATCH 3/3] fix: fix unit test errors related to dataset relations

---
 .../java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java   | 3 +++
 .../edu/harvard/iq/dataverse/util/json/JsonParserTest.java     | 2 +-
 .../edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java    | 2 ++
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
index ddd383fdff7..cd26102ed6f 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
@@ -1234,6 +1234,9 @@ public static JsonObjectBuilder json(DatasetRelation rel, Dataset forDataset, bo
     }
 
     public static JsonArrayBuilder json(List<DatasetRelation> rel, Dataset forDataset, boolean includeMetadataBlocks) {
+        if (rel == null) {
+            return null;
+        }
         return rel.stream().map(r -> json(r, forDataset, includeMetadataBlocks)).collect(toJsonArray());
     }
 
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
index 583b9afe389..84fad67243f 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonParserTest.java
@@ -836,7 +836,7 @@ public void testGuestbook() throws JsonParseException {
 
     @Test
     public void testParseExternalDatasetRelationDTOWithDatasetType() throws JsonParseException {
-        String json = "{\"externalIdentifier\":\"10.1234/ext-1\", \"identifierScheme\":\"doi\", \"datasetType\":\"Journal Article\", \"relationTypeName\":\"isReferencedBy\"}";
+        String json = "{\"externalIdentifier\":\"10.1234/ext-1\", \"identifierScheme\":\"doi\", \"relatedDatasetType\":{\"displayName\":\"Journal Article\"}, \"relationType\":{\"name\":\"isReferencedBy\"}}";
         JsonObject jsonObject = JsonUtil.getJsonObject(json);
         DatasetRelationDTO dto = sut.parseDatasetRelationDTO(jsonObject);
 
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
index 5d5b5b395be..4058cd584dd 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
@@ -851,6 +851,7 @@ public void testPrintExternalDatasetRelation() {
         DatasetRelationType type = new DatasetRelationType("isReferencedBy", "Is referenced by");
 
         ExternalDatasetRelation rel = new ExternalDatasetRelation(dataset, "10.1234/ext-1", "doi", "Journal Article", type, version);
+        rel.setId(1L);
 
         JsonObject result = JsonPrinter.json(rel, false, false).build();
 
@@ -892,6 +893,7 @@ public void testPrintInternalDatasetRelation() {
         DatasetRelationType relTypeInv = new DatasetRelationType("references", "References", null, relType);
 
         InternalDatasetRelation rel = new InternalDatasetRelation(datasetA, datasetB, relType, version);
+        rel.setId(1L);
 
         // Printing with invertRelation = false
         JsonObject result = JsonPrinter.json(rel, false, false).build();