diff --git a/doc/release-notes/11562-templates-api.md b/doc/release-notes/11562-templates-api.md
new file mode 100644
index 00000000000..30e35687a33
--- /dev/null
+++ b/doc/release-notes/11562-templates-api.md
@@ -0,0 +1,4 @@
+New endpoints have been implemented in the Dataverses API for the management of dataverse templates:
+
+- POST `/dataverses/{id}/templates`: Creates a template for a given Dataverse collection ``id``.
+- GET `/dataverses/{id}/templates`: Lists the templates for a given Dataverse collection ``id``.
diff --git a/doc/sphinx-guides/source/_static/api/dataverse-template.json b/doc/sphinx-guides/source/_static/api/dataverse-template.json
new file mode 100644
index 00000000000..373d3edefa7
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/dataverse-template.json
@@ -0,0 +1,27 @@
+{
+  "name": "Dataverse template",
+  "isDefault": true,
+  "fields": [
+    {
+      "typeName": "author",
+      "value": [
+        {
+          "authorName": {
+            "typeName": "authorName",
+            "value": "Belicheck, Bill"
+          },
+          "authorAffiliation": {
+            "typeName": "authorIdentifierScheme",
+            "value": "ORCID"
+          }
+        }
+      ]
+    }
+  ],
+  "instructions": [
+    {
+      "instructionField": "author",
+      "instructionText": "The author data"
+    }
+  ]
+}
diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
index 293fc94638d..da93d357534 100644
--- a/doc/sphinx-guides/source/api/native-api.rst
+++ b/doc/sphinx-guides/source/api/native-api.rst
@@ -1400,6 +1400,46 @@ The fully expanded example above (without environment variables) looks like this
 
   curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X GET "https://demo.dataverse.org/api/access/dataverseFeaturedItemImage/1"
 
+List Templates of a Collection
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Lists the templates for a given Dataverse collection ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X GET "$SERVER_URL/api/dataverses/{ID}/templates"
+
+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 GET "https://demo.dataverse.org/api/dataverses/1/templates"
+
+Create a Template for a Collection
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Creates a template for a given Dataverse collection ``id``.
+
+To create the template, you must send a JSON file. Your JSON file might look like :download:`dataverse-template.json <../_static/api/dataverse-template.json>` which you would send to the Dataverse installation like this:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -X POST "$SERVER_URL/api/dataverses/{ID}/templates" --upload-file dataverse-template.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" -X POST "https://demo.dataverse.org/api/dataverses/1/templates" --upload-file dataverse-template.json
+
 Datasets
 --------
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java b/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
index 029732591ee..4d6d59cb013 100644
--- a/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
+++ b/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
@@ -6,6 +6,7 @@
 import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
 import edu.harvard.iq.dataverse.authorization.providers.builtin.BuiltinUserServiceBean;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
+import edu.harvard.iq.dataverse.license.LicenseServiceBean;
 import edu.harvard.iq.dataverse.util.cache.CacheFactoryBean;
 import edu.harvard.iq.dataverse.engine.DataverseEngine;
 import edu.harvard.iq.dataverse.authorization.Permission;
@@ -192,6 +193,9 @@ public class EjbDataverseEngine {
     @EJB
     DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceBean;
 
+    @EJB
+    LicenseServiceBean licenseServiceBean;
+
     @EJB
     DatasetFieldsValidator datasetFieldsValidator;
     
@@ -541,6 +545,11 @@ public DatasetFieldsValidator datasetFieldsValidator() {
                     return datasetFieldsValidator;
                 }
 
+                @Override
+                public LicenseServiceBean licenses() {
+                    return licenseServiceBean;
+                }
+
                 @Override
                 public StorageUseServiceBean storageUse() {
                     return storageUseService;
diff --git a/src/main/java/edu/harvard/iq/dataverse/Template.java b/src/main/java/edu/harvard/iq/dataverse/Template.java
index 05c6df51197..2768cf417a4 100644
--- a/src/main/java/edu/harvard/iq/dataverse/Template.java
+++ b/src/main/java/edu/harvard/iq/dataverse/Template.java
@@ -137,7 +137,11 @@ public List<DatasetField> getDatasetFields() {
 
     @Transient
     private Map<String, String> instructionsMap = null;
-    
+
+    public void setInstructionsMap(Map<String, String> instructionsMap) {
+        this.instructionsMap = instructionsMap;
+    }
+
     @Transient
     private TreeMap<MetadataBlock, List<DatasetField>> metadataBlocksForView = new TreeMap<>();
     @Transient
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index b1d56b6b8a9..b2ae97a0c7f 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -1931,4 +1931,34 @@ public Response deleteFeaturedItems(@Context ContainerRequestContext crc, @PathP
             return e.getResponse();
         }
     }
+
+    @GET
+    @AuthRequired
+    @Path("{identifier}/templates")
+    public Response getTemplates(@Context ContainerRequestContext crc, @PathParam("identifier") String dvIdtf) {
+        try {
+            Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            return ok(jsonTemplates(execCommand(new ListDataverseTemplatesCommand(createDataverseRequest(getRequestUser(crc)), dataverse))));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+
+    @POST
+    @AuthRequired
+    @Path("{identifier}/templates")
+    public Response createTemplate(@Context ContainerRequestContext crc, String body, @PathParam("identifier") String dvIdtf) {
+        try {
+            Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            NewTemplateDTO newTemplateDTO;
+            try {
+                newTemplateDTO = NewTemplateDTO.fromRequestBody(body, jsonParser());
+            } catch (JsonParseException ex) {
+                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
+            }
+            return ok(jsonTemplate(execCommand(new CreateTemplateCommand(newTemplateDTO.toTemplate(), createDataverseRequest(getRequestUser(crc)), dataverse, true))));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
new file mode 100644
index 00000000000..28e21ffc6c0
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
@@ -0,0 +1,75 @@
+package edu.harvard.iq.dataverse.api.dto;
+
+import edu.harvard.iq.dataverse.*;
+import edu.harvard.iq.dataverse.util.json.JsonParseException;
+import edu.harvard.iq.dataverse.util.json.JsonParser;
+import edu.harvard.iq.dataverse.util.json.JsonUtil;
+import jakarta.json.*;
+
+import java.sql.Timestamp;
+import java.util.*;
+
+public class NewTemplateDTO {
+
+    private String name;
+    private List<DatasetField> datasetFields;
+    private Map<String, String> instructionsMap;
+    private boolean isDefault;
+
+    public static NewTemplateDTO fromRequestBody(String requestBody, JsonParser jsonParser) throws JsonParseException {
+        NewTemplateDTO newTemplateDTO = new NewTemplateDTO();
+
+        JsonObject jsonObject = JsonUtil.getJsonObject(requestBody);
+
+        newTemplateDTO.name = jsonObject.getString("name");
+        newTemplateDTO.datasetFields = jsonParser.parseMultipleFields(jsonObject);
+        newTemplateDTO.instructionsMap = parseRequestBodyInstructionsMap(jsonObject);
+        newTemplateDTO.isDefault = jsonObject.getBoolean("isDefault", false);
+
+        return newTemplateDTO;
+    }
+
+    public Template toTemplate() {
+        Template template = new Template();
+
+        template.setDatasetFields(getDatasetFields());
+        template.setName(getName());
+        template.setInstructionsMap(getInstructionsMap());
+        template.updateInstructions();
+        template.setCreateTime(new Timestamp(new Date().getTime()));
+        template.setUsageCount(0L);
+
+        return template;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<DatasetField> getDatasetFields() {
+        return datasetFields;
+    }
+
+    public Map<String, String> getInstructionsMap() {
+        return instructionsMap;
+    }
+
+    public boolean isDefault() {
+        return isDefault;
+    }
+
+    private static Map<String, String> parseRequestBodyInstructionsMap(JsonObject jsonObject) {
+        Map<String, String> instructionsMap = new HashMap<>();
+        JsonArray instructionsJsonArray = jsonObject.getJsonArray("instructions");
+        if (instructionsJsonArray == null) {
+            return null;
+        }
+        for (JsonObject instructionJsonObject : instructionsJsonArray.getValuesAs(JsonObject.class)) {
+            instructionsMap.put(
+                    instructionJsonObject.getString("instructionField"),
+                    instructionJsonObject.getString("instructionText")
+            );
+        }
+        return instructionsMap;
+    }
+}
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 f7a268abf64..1945d44cd78 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
@@ -4,6 +4,7 @@
 import edu.harvard.iq.dataverse.dataset.DatasetFieldsValidator;
 import edu.harvard.iq.dataverse.authorization.providers.builtin.BuiltinUserServiceBean;
 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;
@@ -140,4 +141,6 @@ public interface CommandContext {
     public DataverseFeaturedItemServiceBean dataverseFeaturedItems();
 
     public DatasetFieldsValidator datasetFieldsValidator();
+
+    public LicenseServiceBean licenses();
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
index 03177ee8c1f..32c63e55cb4 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
@@ -1,7 +1,6 @@
-
 package edu.harvard.iq.dataverse.engine.command.impl;
-import edu.harvard.iq.dataverse.Dataverse;
-import edu.harvard.iq.dataverse.Template;
+
+import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.authorization.Permission;
 
 import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
@@ -9,25 +8,81 @@
 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.settings.JvmSettings;
+import edu.harvard.iq.dataverse.util.DatasetFieldUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
 /**
- *
  * @author skraffmiller
+ * Creates a template {@link Template} for a {@link Dataverse}.
  */
-@RequiredPermissions( Permission.EditDataverse )
+@RequiredPermissions(Permission.EditDataverse)
 public class CreateTemplateCommand extends AbstractCommand<Template> {
-    	private final Template created;
-	private final Dataverse dv;
-	
-	public CreateTemplateCommand(Template template, DataverseRequest aRequest, Dataverse anAffectedDataverse) {
-		super(aRequest, anAffectedDataverse);
-		created = template;
-		dv = anAffectedDataverse;
-	}
-
-	@Override
-	public Template execute(CommandContext ctxt) throws CommandException {
-                
-		return ctxt.templates().save(created);
-	}
-    
+    private final Template template;
+    private final Dataverse dataverse;
+
+    private final boolean initialize;
+
+    public CreateTemplateCommand(Template template, DataverseRequest request, Dataverse dataverse) {
+        this(template, request, dataverse, false);
+    }
+
+    public CreateTemplateCommand(Template template, DataverseRequest request, Dataverse dataverse, boolean initialize) {
+        super(request, dataverse);
+        this.template = template;
+        this.dataverse = dataverse;
+        this.initialize = initialize;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        if (initialize) {
+            template.setDataverse(dataverse);
+            template.setMetadataValueBlocks(getSystemMetadataBlocks(ctxt));
+
+            updateTermsOfUseAndAccess(ctxt, template);
+            updateDatasetFieldInputLevels(template, ctxt);
+
+            DatasetFieldUtil.tidyUpFields(template.getDatasetFields(), false);
+        }
+
+        return ctxt.templates().save(template);
+    }
+
+    private static void updateTermsOfUseAndAccess(CommandContext ctxt, Template template) {
+        TermsOfUseAndAccess terms = new TermsOfUseAndAccess();
+        terms.setFileAccessRequest(true);
+        terms.setTemplate(template);
+        terms.setLicense(ctxt.licenses().getDefault());
+        template.setTermsOfUseAndAccess(terms);
+    }
+
+    private void updateDatasetFieldInputLevels(Template template, CommandContext ctxt) {
+        Long dvIdForInputLevel = this.dataverse.getId();
+        if (!this.dataverse.isMetadataBlockRoot()) {
+            dvIdForInputLevel = this.dataverse.getMetadataRootId();
+        }
+
+        for (DatasetField dsf : template.getFlatDatasetFields()) {
+            DataverseFieldTypeInputLevel inputLevel = ctxt.fieldTypeInputLevels().findByDataverseIdDatasetFieldTypeId(
+                    dvIdForInputLevel,
+                    dsf.getDatasetFieldType().getId()
+            );
+            if (inputLevel != null) {
+                dsf.setInclude(inputLevel.isInclude());
+            } else {
+                dsf.setInclude(true);
+            }
+        }
+    }
+
+    private static List<MetadataBlock> getSystemMetadataBlocks(CommandContext ctxt) {
+        List<MetadataBlock> systemMetadataBlocks = new ArrayList<>();
+        for (MetadataBlock mdb : ctxt.metadataBlocks().listMetadataBlocks()) {
+            JvmSettings.MDB_SYSTEM_KEY_FOR.lookupOptional(mdb.getName()).ifPresent(smdbString -> systemMetadataBlocks.add(mdb));
+        }
+        return systemMetadataBlocks;
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java
new file mode 100644
index 00000000000..f1104b5af15
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java
@@ -0,0 +1,39 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+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 java.util.*;
+
+/**
+ * Lists the templates {@link Template} of a {@link Dataverse}.
+ */
+@RequiredPermissions(Permission.EditDataverse)
+public class ListDataverseTemplatesCommand extends AbstractCommand<List<Template>> {
+
+    private final Dataverse dataverse;
+
+    public ListDataverseTemplatesCommand(DataverseRequest request, Dataverse dataverse) {
+        super(request, dataverse);
+        this.dataverse = dataverse;
+    }
+
+    @Override
+    public List<Template> execute(CommandContext ctxt) throws CommandException {
+        List<Template> templates = new ArrayList<>();
+
+        if (dataverse.getOwner() != null) {
+            templates.addAll(dataverse.getParentTemplates());
+        }
+
+        templates.addAll(dataverse.getTemplates());
+
+        return templates;
+    }
+}
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 23bdd460160..5066a635868 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
@@ -1554,4 +1554,58 @@ public static JsonObjectBuilder json(DataverseFeaturedItem dataverseFeaturedItem
         }
         return job;
     }
+
+    public static JsonArrayBuilder jsonTemplates(List<Template> templates) {
+        JsonArrayBuilder templatesArrayBuilder = Json.createArrayBuilder();
+        for (Template template : templates) {
+            templatesArrayBuilder.add(jsonTemplate(template));
+        }
+        return templatesArrayBuilder;
+    }
+
+    public static JsonObjectBuilder jsonTemplate(Template template) {
+        return jsonObjectBuilder()
+                .add("id", template.getId())
+                .add("name", template.getName())
+                .add("usageCount", template.getUsageCount())
+                .add("createTime", template.getCreateTime().toString())
+                .add("createDate", template.getCreateDate())
+                .add("termsOfUseAndAccess", jsonTermsOfUseAndAccess(template.getTermsOfUseAndAccess()))
+                .add("datasetFields", jsonByBlocks(template.getDatasetFields()))
+                .add("instructions", jsonTemplateInstructions(template.getInstructionsMap()))
+                .add("dataverseAlias", template.getDataverse().getAlias());
+    }
+
+    public static JsonObjectBuilder jsonTermsOfUseAndAccess(TermsOfUseAndAccess termsOfUseAndAccess) {
+        return jsonObjectBuilder()
+                .add("id", termsOfUseAndAccess.getId())
+                .add("license", json(termsOfUseAndAccess.getLicense()))
+                .add("termsOfUse", termsOfUseAndAccess.getTermsOfUse())
+                .add("termsOfAccess", termsOfUseAndAccess.getTermsOfAccess())
+                .add("confidentialityDeclaration", termsOfUseAndAccess.getConfidentialityDeclaration())
+                .add("specialPermissions", termsOfUseAndAccess.getSpecialPermissions())
+                .add("restrictions", termsOfUseAndAccess.getRestrictions())
+                .add("citationRequirements", termsOfUseAndAccess.getCitationRequirements())
+                .add("depositorRequirements", termsOfUseAndAccess.getDepositorRequirements())
+                .add("conditions", termsOfUseAndAccess.getConditions())
+                .add("disclaimer", termsOfUseAndAccess.getDisclaimer())
+                .add("dataAccessPlace", termsOfUseAndAccess.getDataAccessPlace())
+                .add("originalArchive", termsOfUseAndAccess.getOriginalArchive())
+                .add("availabilityStatus", termsOfUseAndAccess.getAvailabilityStatus())
+                .add("sizeOfCollection", termsOfUseAndAccess.getSizeOfCollection())
+                .add("studyCompletion", termsOfUseAndAccess.getStudyCompletion());
+    }
+
+    public static JsonArrayBuilder jsonTemplateInstructions(Map<String, String> templateInstructions) {
+        JsonArrayBuilder jsonArrayBuilder = Json.createArrayBuilder();
+
+        for (Map.Entry<String, String> entry : templateInstructions.entrySet()) {
+            JsonObjectBuilder instructionObject = Json.createObjectBuilder()
+                    .add("instructionField", entry.getKey())
+                    .add("instructionText", entry.getValue());
+            jsonArrayBuilder.add(instructionObject);
+        }
+
+        return jsonArrayBuilder;
+    }
 }
diff --git a/src/main/java/propertyFiles/Bundle.properties b/src/main/java/propertyFiles/Bundle.properties
index 6560b914f56..e07d7731015 100644
--- a/src/main/java/propertyFiles/Bundle.properties
+++ b/src/main/java/propertyFiles/Bundle.properties
@@ -1029,6 +1029,7 @@ dataverse.update.featuredItems.error.invalidTypeAndDvObject=Invalid type and DvO
 dataverse.update.featuredItems.error.invalidType=Unknown 'type' must be one of {0}
 dataverse.update.featuredItems.error.typeAndDvObjectMismatch=The 'type' passed does not match the dvObject type.
 dataverse.delete.featuredItems.success=All featured items of this Dataverse have been successfully deleted.
+dataverse.createTemplate.error.jsonParseMetadataFields=Error parsing the POSTed template dataset fields: {0}
 # rolesAndPermissionsFragment.xhtml
 
 # advanced.xhtml
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 1c1c66205ee..3e1a160c9f2 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2284,6 +2284,93 @@ public void testUpdateInputLevelDisplayOnCreateOverride() {
         
     }
 
+    @Test
+    public void testCreateAndGetTemplates() {
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+
+        Response createSecondUserResponse = UtilIT.createRandomUser();
+        String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
+
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+
+        // Create a template
+
+        String jsonString = """
+                {
+                  "name": "Dataverse template",
+                  "isDefault": true,
+                  "fields": [
+                    {
+                      "typeName": "author",
+                      "value": [
+                        {
+                          "authorName": {
+                            "typeName": "authorName",
+                            "value": "Belicheck, Bill"
+                          },
+                          "authorAffiliation": {
+                            "typeName": "authorIdentifierScheme",
+                            "value": "ORCID"
+                          }
+                        }
+                      ]
+                    }
+                  ],
+                  "instructions": [
+                    {
+                        "instructionField": "author",
+                        "instructionText": "The author data"
+                    }
+                  ]
+                }
+                """;
+
+        Response createTemplateResponse = UtilIT.createTemplate(
+                dataverseAlias,
+                jsonString,
+                apiToken
+        );
+        createTemplateResponse.then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.name", equalTo("Dataverse template"))
+                .body("data.usageCount", equalTo(0))
+                .body("data.termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
+                .body("data.datasetFields.citation.fields.size()", equalTo(1))
+                .body("data.instructions.size()", equalTo(1))
+                .body("data.instructions[0].instructionField", equalTo("author"))
+                .body("data.instructions[0].instructionText", equalTo("The author data"))
+                .body("data.dataverseAlias", equalTo(dataverseAlias));
+
+        // Template creation should fail if the user lacks dataverse edit permissions
+
+        createTemplateResponse = UtilIT.createTemplate(
+                dataverseAlias,
+                jsonString,
+                secondApiToken
+        );
+        createTemplateResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Get templates
+
+        Response getTemplateResponse = UtilIT.getTemplates(dataverseAlias, apiToken);
+        getTemplateResponse.then().assertThat().statusCode(OK.getStatusCode())
+                .body("data.size()", equalTo(1))
+                .body("data[0].name", equalTo("Dataverse template"))
+                .body("data[0].usageCount", equalTo(0))
+                .body("data[0].termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
+                .body("data[0].datasetFields.citation.fields.size()", equalTo(1))
+                .body("data[0].instructions.size()", equalTo(1))
+                .body("data[0].instructions[0].instructionField", equalTo("author"))
+                .body("data[0].instructions[0].instructionText", equalTo("The author data"))
+                .body("data[0].dataverseAlias", equalTo(dataverseAlias));
+
+        // Templates retrieval should fail if the user lacks dataverse edit permissions
+        getTemplateResponse = UtilIT.getTemplates(dataverseAlias, secondApiToken);
+        getTemplateResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+    }
+
     private String getSuperuserToken() {
         Response createResponse = UtilIT.createRandomUser();
         String adminApiToken = UtilIT.getApiTokenFromResponse(createResponse);
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 9bceb3919f8..ea04dae54ff 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -3921,14 +3921,14 @@ static Response deleteDatasetCurationLabel(Integer datasetId, String apiToken) {
                 .delete("/api/datasets/" + datasetId + "/curationStatus");
         return response;
     }
-    
+
     static Response getDatasetCurationStatus(Integer datasetId, String apiToken, boolean includeHistory) {
         Response response = given()
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .get("/api/datasets/" + datasetId + "/curationStatus?includeHistory=" + includeHistory);
         return response;
     }
-    
+
     static Response getDatasetVersionArchivalStatus(Integer datasetId, String version, String apiToken) {
         Response response = given()
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
@@ -4903,4 +4903,19 @@ public static Response getLocalContextsProject(String datasetIdOrPersistentId, S
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .get("/api/localcontexts/datasets/" + idInPath + "/" +projectId + optionalQueryParam);
     }
+
+    public static Response createTemplate(String dataverseAlias, String jsonString, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .post("/api/dataverses/" + dataverseAlias + "/templates");
+    }
+
+    public static Response getTemplates(String dataverseAlias, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .get("/api/dataverses/" + dataverseAlias + "/templates");
+    }
 }
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 ceb0ac21c6a..573c0f48a53 100644
--- a/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
@@ -14,6 +14,7 @@
 import edu.harvard.iq.dataverse.engine.command.Command;
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
 import edu.harvard.iq.dataverse.ingest.IngestServiceBean;
+import edu.harvard.iq.dataverse.license.LicenseServiceBean;
 import edu.harvard.iq.dataverse.pidproviders.PidProviderFactoryBean;
 import edu.harvard.iq.dataverse.privateurl.PrivateUrlServiceBean;
 import edu.harvard.iq.dataverse.search.IndexBatchServiceBean;
@@ -258,6 +259,11 @@ public DatasetFieldsValidator datasetFieldsValidator() {
         return null;
     }
 
+    @Override
+    public LicenseServiceBean licenses() {
+        return null;
+    }
+
     @Override
     public void beginCommandSequence() {
         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java
new file mode 100644
index 00000000000..bf3daa6c593
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java
@@ -0,0 +1,142 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.*;
+import edu.harvard.iq.dataverse.license.License;
+import edu.harvard.iq.dataverse.license.LicenseServiceBean;
+import edu.harvard.iq.dataverse.settings.JvmSettings;
+import edu.harvard.iq.dataverse.util.DatasetFieldUtil;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.util.testing.JvmSetting;
+import edu.harvard.iq.dataverse.util.testing.LocalJvmSettings;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+@LocalJvmSettings
+public class CreateTemplateCommandTest {
+
+    private DataverseRequest dataverseRequestStub;
+
+    @Mock
+    private CommandContext contextMock;
+    @Mock
+    private TemplateServiceBean templateServiceBeanStub;
+    @Mock
+    private MetadataBlockServiceBean metadataBlockServiceBeanMock;
+    @Mock
+    private LicenseServiceBean licenseServiceBeanMock;
+    @Mock
+    private DataverseFieldTypeInputLevelServiceBean fieldTypeInputLevelServiceBeanMock;
+
+    @Spy
+    private Template templateSpy;
+
+    @Mock
+    private Dataverse dataverseMock;
+
+    @BeforeEach
+    public void setUp() {
+        dataverseRequestStub = Mockito.mock(DataverseRequest.class);
+        when(contextMock.templates()).thenReturn(templateServiceBeanStub);
+    }
+
+    @Test
+    public void execute_shouldSaveTemplate_noInitialization() throws CommandException {
+        // Create the command with initialization set to false
+
+        CreateTemplateCommand sut = new CreateTemplateCommand(templateSpy, dataverseRequestStub, dataverseMock, false);
+
+        // Act
+
+        sut.execute(contextMock);
+
+        // Assert
+
+        // Verify that only save was called, and no initialization methods were touched.
+        verify(templateServiceBeanStub).save(templateSpy);
+        verify(templateSpy, never()).setDataverse(any(Dataverse.class));
+        verify(templateSpy, never()).setMetadataValueBlocks(any());
+        verify(templateSpy, never()).setTermsOfUseAndAccess(any());
+    }
+
+    @Test
+    @JvmSetting(key = JvmSettings.MDB_SYSTEM_KEY_FOR, value = "something", varArgs = "citation")
+    public void execute_shouldInitializeAndSaveTemplate_withInitialization() throws CommandException {
+        when(contextMock.metadataBlocks()).thenReturn(metadataBlockServiceBeanMock);
+        when(contextMock.licenses()).thenReturn(licenseServiceBeanMock);
+        when(contextMock.fieldTypeInputLevels()).thenReturn(fieldTypeInputLevelServiceBeanMock);
+
+        when(dataverseMock.getId()).thenReturn(42L);
+        when(dataverseMock.isMetadataBlockRoot()).thenReturn(true);
+
+        // Mock system metadata blocks
+
+        MetadataBlock citationBlock = new MetadataBlock();
+        citationBlock.setName("citation");
+        when(metadataBlockServiceBeanMock.listMetadataBlocks()).thenReturn(List.of(citationBlock));
+
+        // Mock license
+
+        License defaultLicense = new License();
+        defaultLicense.setName("CC0");
+        when(licenseServiceBeanMock.getDefault()).thenReturn(defaultLicense);
+
+        // Mock DatasetFields for input level testing
+
+        DatasetFieldType fieldTypeMock = Mockito.mock(DatasetFieldType.class);
+        Mockito.when(fieldTypeMock.getId()).thenReturn(101L);
+        DatasetField dsf = Mockito.mock(DatasetField.class);
+        Mockito.when(dsf.getDatasetFieldType()).thenReturn(fieldTypeMock);
+        when(templateSpy.getFlatDatasetFields()).thenReturn(Collections.singletonList(dsf));
+
+        // Create the command with initialization set to true
+
+        CreateTemplateCommand sut = new CreateTemplateCommand(templateSpy, dataverseRequestStub, dataverseMock, true);
+
+        // Act
+
+        sut.execute(contextMock);
+
+        // Assert
+
+        // 1. Verify dataverse was set on the template
+        verify(templateSpy).setDataverse(dataverseMock);
+
+        // 2. Verify system metadata blocks were set
+        ArgumentCaptor<List<MetadataBlock>> mdbCaptor = ArgumentCaptor.forClass(List.class);
+        verify(templateSpy).setMetadataValueBlocks(mdbCaptor.capture());
+        assertEquals(1, mdbCaptor.getValue().size());
+        assertEquals("citation", mdbCaptor.getValue().get(0).getName());
+
+        // 3. Verify TermsOfUseAndAccess were created and set correctly
+        ArgumentCaptor<TermsOfUseAndAccess> termsCaptor = ArgumentCaptor.forClass(TermsOfUseAndAccess.class);
+        verify(templateSpy).setTermsOfUseAndAccess(termsCaptor.capture());
+        TermsOfUseAndAccess capturedTerms = termsCaptor.getValue();
+        assertTrue(capturedTerms.isFileAccessRequest());
+        assertEquals("CC0", capturedTerms.getLicense().getName());
+
+        // 4. Verify DatasetFieldInputLevels were checked
+        verify(fieldTypeInputLevelServiceBeanMock).findByDataverseIdDatasetFieldTypeId(42L, 101L);
+
+        // 5. Verify fields were tidied up
+        DatasetFieldUtil.tidyUpFields(templateSpy.getDatasetFields(), false);
+
+        // 6. Finally, verify the fully initialized template was saved
+        verify(templateServiceBeanStub).save(templateSpy);
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java
new file mode 100644
index 00000000000..94be775cf4f
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java
@@ -0,0 +1,79 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ListDataverseTemplatesCommandTest {
+
+    private DataverseRequest dataverseRequestStub;
+    private Template testTemplate;
+
+    @BeforeEach
+    public void setUp() {
+        dataverseRequestStub = Mockito.mock(DataverseRequest.class);
+        testTemplate = new Template();
+    }
+
+    @Test
+    public void execute_shouldReturnTemplates_noParent() throws CommandException {
+        Dataverse dataverseMock = Mockito.mock(Dataverse.class);
+
+        Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
+
+        ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
+
+        List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
+
+        assertEquals(1, result.size());
+        assertEquals(testTemplate, result.get(0));
+    }
+
+    @Test
+    public void execute_shouldReturnTemplates_parentHasTemplates() throws CommandException {
+        Template parentTemplate = new Template();
+
+        Dataverse dataverseMock = Mockito.mock(Dataverse.class);
+        Dataverse parentDataverseMock = Mockito.mock(Dataverse.class);
+
+        Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
+        Mockito.when(dataverseMock.getParentTemplates()).thenReturn(Collections.singletonList(parentTemplate));
+        Mockito.when(dataverseMock.getOwner()).thenReturn(parentDataverseMock);
+
+        ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
+
+        List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
+
+        assertEquals(2, result.size());
+        assertTrue(result.contains(testTemplate));
+        assertTrue(result.contains(parentTemplate));
+    }
+
+    @Test
+    public void execute_shouldReturnTemplates_parentHasNoTemplates() throws CommandException {
+        Dataverse dataverseMock = Mockito.mock(Dataverse.class);
+        Dataverse parentDataverseStub = Mockito.mock(Dataverse.class);
+
+        Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
+        Mockito.when(dataverseMock.getOwner()).thenReturn(parentDataverseStub);
+        Mockito.when(dataverseMock.getParentTemplates()).thenReturn(Collections.emptyList());
+
+        ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
+
+        List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
+
+        assertEquals(1, result.size());
+        assertTrue(result.contains(testTemplate));
+    }
+}