diff --git a/doc/release-notes/11912-edit-template-apis b/doc/release-notes/11912-edit-template-apis
new file mode 100644
index 00000000000..91324f38330
--- /dev/null
+++ b/doc/release-notes/11912-edit-template-apis
@@ -0,0 +1,23 @@
+## New Endpoint: PUT `/dataverses/{templateId}/metadata`
+
+A new endpoint has been implemented to edit the metadata and field instructions for a given template.
+
+### Functionality
+- Updates the metadata and field instructions for a template based on a json file provided.
+- You must have edit dataverse permission in the collection in order to use this endpoint.
+
+## New Endpoint: PUT `/dataverses/{templateId}/licenseTerms`
+
+A new endpoint has been implemented to edit the license or custom terms of use for a given template.
+
+### Functionality
+- Updates the license or custom terms of use for a template based on a json file provided.
+- You must have edit dataverse permission in the collection in order to use this endpoint.
+
+## New Endpoint: PUT `/dataverses/{templateId}/access`
+
+A new endpoint has been implemented to edit the terms of access for a given template.
+
+### Functionality
+- Updates the terms of access for a template based on a json file provided.
+- You must have edit dataverse permission in the collection in order to use this endpoint.
diff --git a/doc/sphinx-guides/source/_static/api/template-update-access.json b/doc/sphinx-guides/source/_static/api/template-update-access.json
new file mode 100644
index 00000000000..e2d86de3283
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-access.json
@@ -0,0 +1,13 @@
+{
+    "customTermsOfAccess": {
+        "fileAccessRequest": false,                              
+        "termsOfAccess": "Here are the terms...",
+        "dataAccessPlace": "dataAccessPlace",
+        "originalArchive": "originalArchive",
+        "availabilityStatus": "availabilityStatus",
+        "contactForAccess": "contactForAccess",
+        "sizeOfCollection": "sizeOfCollection",
+        "studyCompletion": "studyCompletion",
+        "confidentialityDeclaration": "confidentialityDeclaration"
+    }
+}
diff --git a/doc/sphinx-guides/source/_static/api/template-update-license.json b/doc/sphinx-guides/source/_static/api/template-update-license.json
new file mode 100644
index 00000000000..455f4c9d9bd
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-license.json
@@ -0,0 +1 @@
+{ "name": "CC BY 4.0" }
diff --git a/doc/sphinx-guides/source/_static/api/template-update-metadata.json b/doc/sphinx-guides/source/_static/api/template-update-metadata.json
new file mode 100644
index 00000000000..46e201a05f9
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-metadata.json
@@ -0,0 +1,30 @@
+{
+    "name": "Dataverse template - edited",
+    "fields": [
+        {
+            "typeName": "author",
+            "value": [
+                {
+                    "authorName": {
+                        "typeName": "authorName",
+                        "value": "Brady, Tom"
+                    },
+                    "authorAffiliation": {
+                        "typeName": "authorIdentifierScheme",
+                        "value": "ORCID"
+                    }
+                }
+            ]
+        }
+    ],
+    "instructions": [
+        {
+            "instructionField": "author",
+            "instructionText": "The author data, edited"
+        },
+        {
+            "instructionField": "subtitle",
+            "instructionText": "Instructions for subtitle"
+        }
+    ]
+}
diff --git a/doc/sphinx-guides/source/_static/api/template-update-terms.json b/doc/sphinx-guides/source/_static/api/template-update-terms.json
new file mode 100644
index 00000000000..5cf166a83c4
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-terms.json
@@ -0,0 +1,12 @@
+{
+    "customTerms": {
+        "termsOfUse": "testTermsOfUse",
+        "confidentialityDeclaration": "testConfidentialityDeclaration",
+        "specialPermissions": "testSpecialPermissions",
+        "restrictions": "testRestrictions",
+        "citationRequirements": "testCitationRequirements",
+        "depositorRequirements": "testDepositorRequirements",
+        "conditions": "testConditions",
+        "disclaimer": "testDisclaimer"
+    }
+}
diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
index eab71f8623b..6be96c3f8a7 100644
--- a/doc/sphinx-guides/source/api/native-api.rst
+++ b/doc/sphinx-guides/source/api/native-api.rst
@@ -1639,6 +1639,69 @@ The fully expanded example above (without environment variables) looks like this
 
   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
 
+Update the Metadata and Instructions of a Template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates the metadata and instructions of a template with a given ``id``.
+
+To update the template, you must send a JSON file. Your JSON file might look like :download:`template-update-metadata.json <../_static/api/template-update-metadata.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 PUT "$SERVER_URL/api/dataverses/{ID}/metadata" --upload-file template-update-metadata.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 PUT "https://demo.dataverse.org/api/dataverses/1/metadata" --upload-file template-update-metadata.json
+
+Update the License or Terms Of Use of a Template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates the license or custom terms of use of a template with a given ``id``.
+
+To update the template, you must send a JSON file containing either the name of an active license or custom terms of use. Your JSON file might look like :download:`template-update-license.json <../_static/api/template-update-license.json>`  or :download:`template-update-terms.json <../_static/api/template-update-terms.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 PUT "$SERVER_URL/api/dataverses/{ID}/licenseTerms" --upload-file template-update-license.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 PUT "https://demo.dataverse.org/api/dataverses/1/licenseTerms" --upload-file template-update-license.json
+
+Update the Terms Of Access of a Template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates the terms of access of a template with a given ``id``.
+
+To update the template, you must send a JSON file containing either the name of an active license or custom terms of use. Your JSON file might look like :download:`template-update-access.json <../_static/api/template-update-access.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 PUT "$SERVER_URL/api/dataverses/{ID}/access" --upload-file template-update-access.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 PUT "https://demo.dataverse.org/api/dataverses/1/access" --upload-file template-update-access.json
+
 Set a Default Template for a Collection
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
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 2ee5730153e..ffa9ae27f31 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
@@ -242,6 +242,9 @@ String getWrappedMessageWhenJson() {
     
     @EJB 
     GuestbookResponseServiceBean gbRespSvc;
+    
+    @EJB 
+    TemplateServiceBean templateSvc;
 
     @Inject
     FailedPIDResolutionLoggingServiceBean fprLogService;
@@ -370,8 +373,18 @@ protected Dataverse findDataverseOrDie( String dvIdtf ) throws WrappedResponse {
         }
         return dv;
     }
+    
+    protected Template findTemplateOrDie(Long templateId) throws WrappedResponse {
+        
+        Template template = templateSvc.find(templateId);
+        if (template == null) {
+            throw new WrappedResponse(
+                    error(Response.Status.NOT_FOUND, "Can't find template with identifier='" + templateId + "'"));
+        }
+        return template;
+    }
 
-    protected Template findTemplateOrDie(Long templateId, Dataverse dataverse) throws WrappedResponse {
+    protected Template findAllTemplatesOrDie(Long templateId, Dataverse dataverse) throws WrappedResponse {
         
         List<Template> templates = new ArrayList<>();
         
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 caf778be675..b1a95a10282 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -26,6 +26,7 @@
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import edu.harvard.iq.dataverse.engine.command.impl.*;
+import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.pidproviders.PidProvider;
 import edu.harvard.iq.dataverse.pidproviders.PidUtil;
 import edu.harvard.iq.dataverse.settings.JvmSettings;
@@ -72,6 +73,7 @@
 import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.Context;
 import jakarta.ws.rs.core.HttpHeaders;
+import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
 import jakarta.ws.rs.core.StreamingOutput;
 import org.glassfish.jersey.media.multipart.FormDataBodyPart;
 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
@@ -2016,9 +2018,9 @@ public Response getTemplate(@Context ContainerRequestContext crc, @PathParam("id
     public Response createTemplate(@Context ContainerRequestContext crc, String body, @PathParam("identifier") String dvIdtf) {
         try {
             Dataverse dataverse = findDataverseOrDie(dvIdtf);
-            NewTemplateDTO newTemplateDTO;
+            TemplateDTO newTemplateDTO;
             try {
-                newTemplateDTO = NewTemplateDTO.fromRequestBody(body, jsonParser());
+                newTemplateDTO = TemplateDTO.fromRequestBody(body, jsonParser());
             } catch (JsonParseException ex) {
                 return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
             }
@@ -2030,6 +2032,109 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
             return e.getResponse();
         }
     }
+    
+    @PUT
+    @AuthRequired
+    @Path("{templateId}/metadata")
+    public Response updateTemplateMetadata(@Context ContainerRequestContext crc, String body, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
+        try {
+            Template template = findTemplateOrDie(templateId);
+            Dataverse dataverse = template.getDataverse();
+      
+            JsonObject json = JsonUtil.getJsonObject(body);
+            
+            /*
+            You can also set a new name for your template in the json
+            */
+            
+            String templateName = json.getString("name");
+            if (!templateName.isEmpty() && !templateName.isBlank()){
+                 template.setName(templateName);                
+            }
+
+            
+            List<DatasetField> updatedFields = new ArrayList<>();
+            if (json.getJsonArray("fields") == null) {
+                updatedFields.add(jsonParser().parseField(json, Boolean.FALSE, replaceData));
+            } else {
+                updatedFields = jsonParser().parseMultipleFields(json, replaceData);
+            }
+                      
+            Map<String, String> instructionsMap = jsonParser().parseRequestBodyInstructionsMap(json);
+            
+            Template updated = execCommand(new UpdateTemplateFieldsCommand(template, dataverse,  updatedFields, instructionsMap, replaceData, createDataverseRequest(getRequestUser(crc))));
+            
+            return created("/dataverses/template/" + updated.getId(), jsonTemplate(updated));
+                } catch (JsonParseException ex) {
+            logger.log(Level.SEVERE, "Semantic error parsing dataset update Json: " + ex.getMessage(), ex);
+            return error(Response.Status.BAD_REQUEST, BundleUtil.getStringFromBundle("datasets.api.editMetadata.error.parseUpdate", List.of(ex.getMessage())));
+    
+        
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+    
+    @PUT
+    @AuthRequired
+    @Path("{templateId}/licenseTerms")
+    public Response updateTemplateLicenseTerms(@Context ContainerRequestContext crc, LicenseUpdateRequest requestBody, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
+        try {
+            Template template = findTemplateOrDie(templateId);
+            Dataverse dataverse = template.getDataverse();
+            
+            if (requestBody.getName() != null && !requestBody.getName().isEmpty()) {
+                String licenseName = requestBody.getName();
+                License license = licenseSvc.getByNameOrUri(licenseName);
+                if (license == null) {
+                    return notFound(BundleUtil.getStringFromBundle("datasets.api.updateLicense.licenseNotFound", List.of(licenseName)));
+                }
+                
+                execCommand(new UpdateTemplateLicenseCommand(createDataverseRequest(getRequestUser(crc)), template, dataverse, license));
+                return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success"));
+            } else if (requestBody.getCustomTerms() != null) {
+                CustomTermsDTO customTerms = requestBody.getCustomTerms();
+                execCommand(new UpdateTemplateLicenseCommand(createDataverseRequest(getRequestUser(crc)), template, dataverse, customTerms.toTermsOfUseAndAccess()));
+                return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success"));
+            } else {
+                return badRequest(BundleUtil.getStringFromBundle("datasets.api.updateLicense.licenseNameIsEmpty"));
+            }
+        
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+    
+    @PUT
+    @AuthRequired
+    @Path("{templateId}/access")
+    public Response updateTemplateTermsOfAccess(@Context ContainerRequestContext crc, String jsonBody, @PathParam("templateId") Long templateId) {
+        try {
+
+            boolean publicInstall = settingsSvc.isTrueForKey(SettingsServiceBean.Key.PublicInstall, false);
+
+            Template template = findTemplateOrDie(templateId);
+
+            JsonObject json = JsonUtil.getJsonObject(jsonBody);
+
+            TermsOfUseAndAccess toua = jsonParser().parseTermsOfAccess(json);
+
+            if (publicInstall && (toua.isFileAccessRequest() || !toua.getTermsOfAccess().isEmpty())){
+                return error(BAD_REQUEST, "Setting File Access Request or Terms of Access is not permitted on a public installation.");
+            }
+
+            execCommand(new UpdateTemplateTermsOfAccessCommand(createDataverseRequest(getRequestUser(crc)), template, template.getDataverse(), toua ));
+
+            return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.access.success"));
+
+        } catch (JsonParseException ex) {
+            logger.log(Level.SEVERE, "Semantic error parsing template terms update Json: " + ex.getMessage(), ex);
+            return error(Response.Status.BAD_REQUEST, BundleUtil.getStringFromBundle("datasets.api.editMetadata.error.parseUpdate", List.of(ex.getMessage())));
+        } catch (WrappedResponse ex) {
+            logger.log(Level.SEVERE, "Update terms of access error: " + ex.getMessage(), ex);
+            return ex.getResponse();
+        }
+    }
 
     @POST
     @AuthRequired
@@ -2041,7 +2146,7 @@ public Response setDefaultTemplate(@Context ContainerRequestContext crc,
         try {
 
             Dataverse dataverse = findDataverseOrDie(dvId);
-            Template template = findTemplateOrDie(templateId, dataverse);
+            Template template = findAllTemplatesOrDie(templateId, dataverse);
             DataverseRequest dvReq = createDataverseRequest(getRequestUser(crc));
             SetDefaultTemplateCommand command = new SetDefaultTemplateCommand(template, dvReq, dataverse);
             
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
similarity index 52%
rename from src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
rename to src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
index 31adc30f2b9..ace7b27f723 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
@@ -9,24 +9,24 @@
 import java.sql.Timestamp;
 import java.util.*;
 
-public class NewTemplateDTO {
+public class TemplateDTO {
 
     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();
+    public static TemplateDTO fromRequestBody(String requestBody, JsonParser jsonParser) throws JsonParseException {
+        TemplateDTO templateDTO = new TemplateDTO();
 
         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;
+        templateDTO.name = jsonObject.getString("name");
+        templateDTO.datasetFields = jsonParser.parseMultipleFields(jsonObject);
+        templateDTO.instructionsMap = jsonParser.parseRequestBodyInstructionsMap(jsonObject);
+        templateDTO.isDefault = jsonObject.getBoolean("isDefault", false);
+               
+        return templateDTO;
     }
 
     public Template toTemplate() {
@@ -59,18 +59,4 @@ 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/impl/UpdateTemplateFieldsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
new file mode 100644
index 00000000000..f99ed498cc5
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
@@ -0,0 +1,182 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.ControlledVocabularyValue;
+import edu.harvard.iq.dataverse.DatasetField;
+import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
+import edu.harvard.iq.dataverse.DatasetFieldValue;
+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.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+@RequiredPermissions(Permission.EditDataverse)
+public class UpdateTemplateFieldsCommand extends AbstractCommand<Template> {
+
+    private final Template template;   
+    private final List<DatasetField> updatedFields;
+    private  final Map<String, String> instructions;
+    private final boolean replaceData;
+
+    public UpdateTemplateFieldsCommand(Template template, Dataverse dataverse,  List<DatasetField> updatedFields, Map<String, String> instructions, boolean replaceData, DataverseRequest request) {
+        super(request, dataverse);
+        this.template = template;
+        this.updatedFields = updatedFields;
+        this.replaceData = replaceData;
+        this.instructions = instructions;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        /*
+        Since this is a template we do not need to validate the incoming fields - that will occur if
+        the template is used to create a new dataset.
+        */
+                
+        Template savedTemplate;
+        updateTemplateFields(template);
+        updateInstructions(template);
+        savedTemplate = ctxt.templates().save(template);
+
+        return savedTemplate;
+    }
+
+    /**
+     * Updates the template fields by iterating through the updated fields and
+     * comparing them to the existing fields in the template
+     * <p>
+     * - If a matching field exists, its values are added or replaced based on conditions:
+     * - If the field is empty, allows multiple values, or replaceData is enabled, the values are updated.
+     * - If replaceData is enabled, the field is reset before updating.
+     * - If the field is a controlled vocabulary type, it is updated accordingly.
+     * - Otherwise, a regular template field update is performed.
+     * </p>
+     * <p>
+     * - If no matching field exists, the updated field is added to the template.
+     * </p>
+     *
+     * @param template The template to update with the new fields.
+     */
+    private void updateTemplateFields(Template template) {
+        for (DatasetField updatedField : updatedFields) {
+            boolean found = false;
+
+            for (DatasetField datasetVersionField : template.getDatasetFields()) {
+                if (!datasetVersionField.getDatasetFieldType().equals(updatedField.getDatasetFieldType())) {
+                    continue;
+                }
+
+                found = true;
+
+                if (datasetVersionField.isEmpty() || datasetVersionField.getDatasetFieldType().isAllowMultiples() || replaceData) {
+
+                    if (replaceData) {
+                        resetDatasetField(datasetVersionField);
+                    }
+
+                    if (updatedField.getDatasetFieldType().isControlledVocabulary()) {
+                        updateControlledVocabularyDatasetField(
+                                updatedField, datasetVersionField, datasetVersionField.getDisplayValue(),
+                                new ArrayList<>(datasetVersionField.getControlledVocabularyValues())
+                        );
+                    } else {
+                        updateRegularDatasetField(updatedField, datasetVersionField, template);
+                    }
+                    break;
+                }
+            }
+
+            if (!found) {
+                updatedField.setTemplate(template);
+                template.getDatasetFields().add(updatedField);
+            }
+        }
+    }
+
+    private void resetDatasetField(DatasetField datasetVersionField) {
+        if (datasetVersionField.getDatasetFieldType().isAllowMultiples()) {
+            datasetVersionField.setDatasetFieldValues(new ArrayList<>());
+            datasetVersionField.setControlledVocabularyValues(new ArrayList<>());
+            datasetVersionField.setDatasetFieldCompoundValues(new ArrayList<>());
+        } else {
+            datasetVersionField.setSingleValue("");
+            datasetVersionField.setSingleControlledVocabularyValue(null);
+        }
+    }
+
+    private static void updateRegularDatasetField(DatasetField updatedField, DatasetField datasetVersionField, Template template) {
+        if (!updatedField.getDatasetFieldType().isCompound()) {
+            updateSingleDatasetField(updatedField, datasetVersionField);
+        } else {
+            updateCompoundDatasetField(updatedField, datasetVersionField, template);
+        }
+    }
+
+    private static void updateSingleDatasetField(DatasetField updatedField, DatasetField datasetVersionField) {
+        if (datasetVersionField.getDatasetFieldType().isAllowMultiples()) {
+            for (DatasetFieldValue datasetFieldValue : updatedField.getDatasetFieldValues()) {
+                if (!datasetVersionField.getDisplayValue().contains(datasetFieldValue.getDisplayValue())) {
+                    datasetFieldValue.setDatasetField(datasetVersionField);
+                    datasetVersionField.getDatasetFieldValues().add(datasetFieldValue);
+                }
+            }
+        } else {
+            datasetVersionField.setSingleValue(updatedField.getValue());
+        }
+    }
+
+    private static void updateCompoundDatasetField(DatasetField updatedField, DatasetField datasetVersionField, Template template) {
+        for (DatasetFieldCompoundValue datasetFieldCompoundValue : updatedField.getDatasetFieldCompoundValues()) {
+            if (!datasetVersionField.getCompoundDisplayValue().contains(updatedField.getCompoundDisplayValue())) {
+                datasetFieldCompoundValue.setParentDatasetField(datasetVersionField);
+                datasetVersionField.setTemplate(template);
+                datasetVersionField.getDatasetFieldCompoundValues().add(datasetFieldCompoundValue);
+            }
+        }
+    }
+
+    private static void updateControlledVocabularyDatasetField(DatasetField updatedField,
+                                                               DatasetField datasetVersionField,
+                                                               String controlledVocabularyDisplayValue,
+                                                               List<ControlledVocabularyValue> priorControlledVocabularyValues) {
+        if (datasetVersionField.getDatasetFieldType().isAllowMultiples()) {
+            for (ControlledVocabularyValue controlledVocabularyValue : updatedField.getControlledVocabularyValues()) {
+                if (!controlledVocabularyDisplayValue.contains(controlledVocabularyValue.getStrValue())) {
+                    priorControlledVocabularyValues.add(controlledVocabularyValue);
+                }
+            }
+            datasetVersionField.setControlledVocabularyValues(priorControlledVocabularyValues);
+        } else {
+            datasetVersionField.setSingleControlledVocabularyValue(updatedField.getSingleControlledVocabularyValue());
+        }
+    }
+    
+    private void updateInstructions(Template template){
+        if(replaceData){
+            template.setInstructionsMap(instructions);
+            template.updateInstructions();
+        } else {
+            Map <String, String> currentInstructionsMap = template.getInstructionsMap();            
+            Map<String, String> merged = new HashMap<>(currentInstructionsMap);
+            merged.putAll(instructions);
+            template.setInstructionsMap(merged);
+            template.updateInstructions();           
+        }       
+    }
+    
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
new file mode 100644
index 00000000000..126350cf510
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
@@ -0,0 +1,92 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+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.TermsOfUseAndAccess;
+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 edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.license.License;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import java.util.List;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+@RequiredPermissions(Permission.EditDataverse)
+public class UpdateTemplateLicenseCommand extends AbstractCommand<Template>{
+    
+    private License license = null;
+    private TermsOfUseAndAccess customTermsOfUseAndAccess = null;
+    private Template template;
+
+    public UpdateTemplateLicenseCommand(DataverseRequest request, Template template, Dataverse dataverse, License license) {
+        super(request, dataverse);
+        this.template = template;
+        this.license = license;
+    }
+    
+    public UpdateTemplateLicenseCommand(DataverseRequest request, Template template, Dataverse dataverse, TermsOfUseAndAccess customTermsOfUseAndAccess) {
+        super(request, dataverse);
+        this.template = template;
+        this.customTermsOfUseAndAccess = customTermsOfUseAndAccess;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        Template savedTemplate;
+        
+        if (license == null && customTermsOfUseAndAccess == null) {
+            throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.customTermsOfUseNotProvided"), this);
+        }
+
+        if (license != null) {
+            if (!license.isActive()) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.licenseNotActive", List.of(license.getName())), this);
+            }
+            TermsOfUseAndAccess termsOfUseAndAccess = template.getTermsOfUseAndAccess();
+            termsOfUseAndAccess.setLicense(license);
+            savedTemplate = ctxt.templates().save(template);
+
+        } else  {
+            if (customTermsOfUseAndAccess.getTermsOfUse() == null || customTermsOfUseAndAccess.getTermsOfUse().isBlank()) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.customTermsOfUseNotProvided"), this);
+            }
+            TermsOfUseAndAccess termsToUpdate = template.getTermsOfUseAndAccess();
+            applyCustomTerms(termsToUpdate, customTermsOfUseAndAccess);
+            template.setTermsOfUseAndAccess(termsToUpdate);
+            savedTemplate = ctxt.templates().save(template);
+        }
+        
+        return savedTemplate;
+        
+    }
+    
+        /**
+     * Copies all custom term-related fields from the 'source' object
+     * to the 'target' object.
+     *
+     * @param target The TermsOfUseAndAccess object to be modified
+     * @param source The TermsOfUseAndAccess object containing the new data
+     */
+    private void applyCustomTerms(TermsOfUseAndAccess target, TermsOfUseAndAccess source) {
+        target.setTermsOfUse(source.getTermsOfUse());
+        target.setConfidentialityDeclaration(source.getConfidentialityDeclaration());
+        target.setSpecialPermissions(source.getSpecialPermissions());
+        target.setRestrictions(source.getRestrictions());
+        target.setCitationRequirements(source.getCitationRequirements());
+        target.setDepositorRequirements(source.getDepositorRequirements());
+        target.setConditions(source.getConditions());
+        target.setDisclaimer(source.getDisclaimer());
+    }
+    
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
new file mode 100644
index 00000000000..a294257bfe1
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
@@ -0,0 +1,64 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+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.TermsOfUseAndAccess;
+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 edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+@RequiredPermissions(Permission.EditDataverse)
+public class UpdateTemplateTermsOfAccessCommand extends AbstractCommand<Template> {
+    
+    private TermsOfUseAndAccess customTermsOfUseAndAccess = null;
+    private Template template;
+   
+    public UpdateTemplateTermsOfAccessCommand(DataverseRequest request, Template template, Dataverse dataverse, TermsOfUseAndAccess customTermsOfUseAndAccess) {
+        super(request, dataverse);
+        this.template = template;
+        this.customTermsOfUseAndAccess = customTermsOfUseAndAccess;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        Template savedTemplate;
+
+        if (customTermsOfUseAndAccess == null) {
+            throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.customTermsOfUseNotProvided"), this);
+        }
+
+        TermsOfUseAndAccess termsToUpdate = template.getTermsOfUseAndAccess();
+        applyCustomTerms(termsToUpdate, customTermsOfUseAndAccess);
+        template.setTermsOfUseAndAccess(termsToUpdate);
+        savedTemplate = ctxt.templates().save(template);
+
+        return savedTemplate;
+    }
+    
+    private void applyCustomTerms(TermsOfUseAndAccess target, TermsOfUseAndAccess source) {
+        
+        target.setFileAccessRequest(source.isFileAccessRequest());
+        target.setTermsOfAccess(source.getTermsOfAccess());
+        target.setDataAccessPlace(source.getDataAccessPlace());
+        target.setOriginalArchive(source.getOriginalArchive());
+        target.setAvailabilityStatus(source.getAvailabilityStatus());
+        target.setContactForAccess(source.getContactForAccess());
+        target.setSizeOfCollection(source.getSizeOfCollection());
+        target.setStudyCompletion(source.getStudyCompletion());
+    }
+    
+}
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 15cb5d7febf..81d13eeb1b6 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
@@ -646,6 +646,21 @@ 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");
+        if (instructionsJsonArray == null) {
+            return null;
+        }
+        for (JsonObject instructionJsonObject : instructionsJsonArray.getValuesAs(JsonObject.class)) {
+            instructionsMap.put(
+                    instructionJsonObject.getString("instructionField"),
+                    instructionJsonObject.getString("instructionText")
+            );
+        }
+        return instructionsMap;
+    }
 
     public List<DatasetField> parseMultipleFields(JsonObject json) throws JsonParseException {
         return parseMultipleFields(json, false);
diff --git a/src/main/java/propertyFiles/Bundle.properties b/src/main/java/propertyFiles/Bundle.properties
index f6c0054a43a..dbf8c6a9b4d 100644
--- a/src/main/java/propertyFiles/Bundle.properties
+++ b/src/main/java/propertyFiles/Bundle.properties
@@ -2907,6 +2907,10 @@ dataverses.api.validate.json.succeeded=The Dataset JSON provided is valid for th
 dataverses.api.validate.json.failed=The Dataset JSON provided failed validation with the following error:
 dataverses.api.validate.json.exception=Validation failed with following exception:
 dataverses.api.update.featured.items.error.onlyImageFilesAllowed=Invalid file type. Only image files are allowed.
+dataverses.api.update.template.license.success=Template license updated
+dataverses.api.update.template.terms.success=Template Terms of Use updated
+dataverses.api.update.template.access.success=Template Terms of Access updated
+dataverses.api.editMetadata.template.error.parseUpdate==Error parsing template update: {0}
 
 #Access.java
 access.api.allowRequests.failure.noDataset=Could not find Dataset with id: {0}
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 dc658c7134b..874bb1f41fa 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -12,6 +12,7 @@
 
 import io.restassured.response.Response;
 import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
 import edu.harvard.iq.dataverse.util.BundleUtil;
 
@@ -2617,9 +2618,9 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
         String username = UtilIT.getUsernameFromResponse(createUserResponse);
 
-            Response createSecondUserResponse = UtilIT.createRandomUser();
-            String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
-            String secondUsername = UtilIT.getUsernameFromResponse(createSecondUserResponse);
+        Response createSecondUserResponse = UtilIT.createRandomUser();
+        String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
+        String secondUsername = UtilIT.getUsernameFromResponse(createSecondUserResponse);
 
         
         /*
@@ -2630,9 +2631,7 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         createDataverseResponse.prettyPrint();
         createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
         String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
-        Integer dataverseId = UtilIT.getDataverseIdFromResponse(createDataverseResponse);
-        
-        System.out.print("dataverseId: " + dataverseId);
+
         
         String newName = "New Test Dataverse Name";
         String newAffiliation = "New Test Dataverse Affiliation";
@@ -2729,11 +2728,7 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
                 .body("data[0].instructions[0].instructionField", equalTo("author"))
                 .body("data[0].instructions[0].instructionText", equalTo("The author data"))
                 .body("data[0].dataverseAlias", equalTo(dataverseAlias));
-        
-                
-            // Remove default template
-            System.out.print("***************: " + dataverseAlias );
-            
+
             Response removeDefaultResp = UtilIT.removeDefaultTemplate(dataverseAlias, apiToken);
             removeDefaultResp.prettyPrint();
             removeDefaultResp.then().assertThat().statusCode(OK.getStatusCode());       
@@ -2744,7 +2739,7 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
                             .body("data.size()", equalTo(1))
                             .body("data[0].isDefault", equalTo(false));
 
-
+        
             // Templates retrieval should fail if a secondary user lacks dataset creation
             // permissions
 
@@ -2805,6 +2800,272 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         assertEquals(200, deleteUserResponse.getStatusCode());
         
 
+    }
+    
+    
+    @Test
+    public void testUpdateTemplates() throws JsonParseException  {
+        /*
+          Also Terms of Use/access
+        */
+        
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+        String username = UtilIT.getUsernameFromResponse(createUserResponse);
+
+        /*
+        We need to make this a non-inherited metadatablocks so the get template will only get templates from current dv
+         */
+        
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.prettyPrint();
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+        
+        String newName = "New Test Dataverse Name";
+        String newAffiliation = "New Test Dataverse Affiliation";
+        String newDataverseType = Dataverse.DataverseType.TEACHING_COURSES.toString();
+        String[] newContactEmails = new String[]{"new_email@dataverse.com"};
+        String[] newInputLevelNames = new String[]{"geographicCoverage"};
+        String[] newFacetIds = new String[]{"contributorName"};
+        String[] newMetadataBlockNames = new String[]{"citation", "geospatial", "biomedical"};
+
+        // Giving the new Dataverse updated metadatablocks so that it will not inherit
+        // templates
+        Response updateDataverseResponse = UtilIT.updateDataverse(
+                dataverseAlias, dataverseAlias, newName, newAffiliation, newDataverseType, newContactEmails,
+                newInputLevelNames,
+                null, newMetadataBlockNames, apiToken,
+                Boolean.FALSE, Boolean.FALSE, null);
+
+        updateDataverseResponse.then().assertThat()
+                .statusCode(OK.getStatusCode());
+
+        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"
+                                }
+                              ]
+                            }
+                            """;
+        
+        String jsonStringForUpdateNotReplace = """
+                            {
+                              "name": "Dataverse template - edited",
+                              "fields": [
+                                {
+                                  "typeName": "author",
+                                  "value": [
+                                    {
+                                        "authorName": {
+                                            "typeName": "authorName",
+                                            "value": "Brady, Tom"
+                                        },
+                                        "authorAffiliation": {
+                                            "typeName": "authorIdentifierScheme",
+                                            "value": "ORCID"
+                                        }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "instructions": [
+                                {
+                                    "instructionField": "author",
+                                    "instructionText": "The author data, edited"
+                                },
+                                {
+                                    "instructionField": "subtitle",
+                                    "instructionText": "Info on subtitle"
+                                }
+                              ]
+                            }
+                            """;
+        
+                
+        String jsonStringForUpdateReplaceData = """
+                            {
+                              "name": "Dataverse template - edited - again",
+                              "fields": [
+                                {
+                                  "typeName": "author",
+                                  "value": [
+                                    {
+                                        "authorName": {
+                                            "typeName": "authorName",
+                                            "value": "Vrabel, Mike"
+                                        },
+                                        "authorAffiliation": {
+                                            "typeName": "authorIdentifierScheme",
+                                            "value": "ORCID"
+                                        }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "instructions": [
+                                {
+                                    "instructionField": "title",
+                                    "instructionText": "A title for, you know, your thing"
+                                }
+                              ]
+                            }
+                            """;
+        
+                String jsonStringForUpdateTerms = """
+            {
+                   "customTerms": {
+                     "termsOfUse": "testTermsOfUse",
+                     "confidentialityDeclaration": "testConfidentialityDeclaration",
+                     "specialPermissions": "testSpecialPermissions",
+                     "restrictions": "testRestrictions",
+                     "citationRequirements": "testCitationRequirements",
+                     "depositorRequirements": "testDepositorRequirements",
+                     "conditions": "testConditions",
+                     "disclaimer": "testDisclaimer"
+                   }
+                 }
+                            """;
+                
+                String jsonStringForUpdateAccess = """
+            {
+                   "customTermsOfAccess": {
+                     "fileAccessRequest": false,                              
+                     "termsOfAccess": "Here are the terms...",
+                     "dataAccessPlace": "dataAccessPlace",
+                     "originalArchive": "originalArchive",
+                     "availabilityStatus": "availabilityStatus",
+                     "contactForAccess": "contactForAccess",
+                     "sizeOfCollection": "sizeOfCollection",
+                     "studyCompletion": "studyCompletion",
+                     "confidentialityDeclaration": "confidentialityDeclaration"
+                   }
+                 }
+                            """;
+
+
+        Response createTemplateResponse = UtilIT.createTemplate(
+                dataverseAlias,
+                jsonString,
+                apiToken);
+        
+        createTemplateResponse.prettyPrint();
+
+        createTemplateResponse.then().assertThat().statusCode(CREATED.getStatusCode())
+                .body("data.name", equalTo("Dataverse template"))
+                .body("data.isDefault", equalTo(true))
+                .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));
+
+        Long templateId = createTemplateResponse.body().jsonPath().getLong("data.id");
+        
+        
+        Response updateTemplateResponse = UtilIT.updateTemplateMetadata(templateId.toString(), jsonStringForUpdateNotReplace, apiToken, false);
+        
+        updateTemplateResponse.prettyPrint();
+
+        updateTemplateResponse.then().assertThat().statusCode(CREATED.getStatusCode())
+                .body("data.name", equalTo("Dataverse template - edited"))
+                .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(2))
+                .body("data.dataverseAlias", equalTo(dataverseAlias));
+        
+        Response updateTemplateReplaceResponse = UtilIT.updateTemplateMetadata(templateId.toString(), jsonStringForUpdateReplaceData, apiToken, true);
+        
+        updateTemplateReplaceResponse.prettyPrint();
+
+        updateTemplateReplaceResponse.then().assertThat().statusCode(CREATED.getStatusCode())
+                .body("data.name", equalTo("Dataverse template - edited - again"))
+                .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.dataverseAlias", equalTo(dataverseAlias));
+        
+        
+        //Update Template License
+                // Test case 1: Update to a valid, predefined license (CC BY 4.0).
+        Response updateLicenseResponse = UtilIT.updateTemplateLicenseTerms(templateId.toString(), "{ \"name\": \"CC BY 4.0\" }", apiToken);
+        updateLicenseResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.message", equalTo(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success")));
+
+        Response getTemplate  = UtilIT.getTemplate(templateId.toString(),  apiToken);
+        getTemplate.prettyPrint();
+        getTemplate.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.termsOfUseAndAccess.license.name", equalTo("CC BY 4.0"));
+        
+        Response updateTermsResponse = UtilIT.updateTemplateLicenseTerms(templateId.toString(), jsonStringForUpdateTerms, apiToken);
+        updateTermsResponse.prettyPrint();
+
+        
+
+        updateTermsResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.message", equalTo(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success")));
+
+        getTemplate  = UtilIT.getTemplate(templateId.toString(),  apiToken);
+        getTemplate.prettyPrint();
+                getTemplate.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.termsOfUseAndAccess.termsOfUse", equalTo("testTermsOfUse"));
+                
+        Response updateAccessResponse = UtilIT.updateTemplateAccessTerms(templateId.toString(), jsonStringForUpdateAccess, apiToken);
+
+        updateAccessResponse.prettyPrint();
+                updateAccessResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.message", equalTo(BundleUtil.getStringFromBundle("dataverses.api.update.template.access.success")));
+
+                
+        getTemplate  = UtilIT.getTemplate(templateId.toString(),  apiToken);
+        getTemplate.prettyPrint();
+                getTemplate.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.termsOfUseAndAccess.termsOfAccess", equalTo("Here are the terms..."));        
+        // back to super for cleanup
+        
+        UtilIT.setSuperuserStatus(username, true);
+        
+        Response deleteDataverse1Response = UtilIT.deleteDataverse(dataverseAlias, apiToken);
+        deleteDataverse1Response.prettyPrint();
+        assertEquals(200, deleteDataverse1Response.getStatusCode());
+        
+        Response deleteUserResponse = UtilIT.deleteUser(username);
+        deleteUserResponse.prettyPrint();
+        assertEquals(200, deleteUserResponse.getStatusCode()); 
+
+
     }
 
     @Test
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 24ab8b56eff..887c4040191 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5157,6 +5157,31 @@ public static Response createTemplate(String dataverseAlias, String jsonString,
                 .post("/api/dataverses/" + dataverseAlias + "/templates");
     }
     
+    public static Response updateTemplateMetadata(String templateId, String jsonString, String apiToken, Boolean replaceData) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .put("/api/dataverses/" + templateId + "/metadata?replace=" + replaceData);
+    }
+    
+    public static Response updateTemplateLicenseTerms(String templateId, String jsonString, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .put("/api/dataverses/" + templateId + "/licenseTerms");
+    }
+    
+        
+    public static Response updateTemplateAccessTerms(String templateId, String jsonString, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .put("/api/dataverses/" + templateId + "/access");
+    }
+    
     public static Response deleteTemplate(String id,  String apiToken) {
         return given()
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java
new file mode 100644
index 00000000000..ef24e4349e7
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java
@@ -0,0 +1,181 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.DatasetField;
+import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
+import edu.harvard.iq.dataverse.DatasetFieldType;
+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.TemplateServiceBean;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+@ExtendWith(MockitoExtension.class)
+public class UpdateTemplateFieldsCommandTest {
+
+    @Mock
+    private CommandContext ctxt;
+    @Mock
+    private TemplateServiceBean templateService;
+    @Mock
+    private DataverseRequest request;
+    @Mock
+    private Dataverse dataverse;
+
+    private Template template;
+    private List<DatasetField> updatedFields;
+    private Map<String, String> instructions;
+
+    @BeforeEach
+    void setUp() {
+        template = new Template();
+        template.setDatasetFields(new ArrayList<>());
+        updatedFields = new ArrayList<>();
+        instructions = new HashMap<>();
+
+        lenient().when(ctxt.templates()).thenReturn(templateService);
+        lenient().when(templateService.save(any(Template.class))).thenAnswer(i -> i.getArguments()[0]);
+    }
+
+    @Test
+    void testExecute_AddNewField() throws Exception {
+        // Arrange: Updated fields contains a field not in the template
+        DatasetField newField = createPrimitiveField("title", "New Template Title");
+        updatedFields.add(newField);
+
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(template, dataverse, updatedFields, instructions, false, request);
+
+        // Act
+        Template result = cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(1, result.getDatasetFields().size());
+        assertEquals("New Template Title", result.getDatasetFields().get(0).getValue());
+    }
+
+    @Test
+    void testExecute_ReplaceExistingData() throws Exception {
+        // Arrange: Template has an existing field
+        DatasetField existingField = createPrimitiveField("description", "Old Description");
+ 
+        template.getDatasetFields().add(existingField);
+        existingField.setTemplate(template);
+
+        // New field with same type but different value
+        DatasetField newField = createPrimitiveField("description", "New Description");
+        updatedFields.add(newField);
+
+        // replaceData = true
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(template, dataverse, updatedFields, instructions, true, request);
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(1, template.getDatasetFields().size());
+        assertEquals("New Description", template.getDatasetFields().get(0).getValue());
+    }
+
+    @Test
+    void testUpdateInstructions_MergeLogic() throws Exception {
+        // Arrange
+        template.setInstructionsMap(new HashMap<>(Map.of("field1", "old instruction")));
+        instructions.put("field2", "new instruction");
+
+        // replaceData = false (Merge)
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(template, dataverse, updatedFields, instructions, false, request);
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        Map<String, String> resultInstructions = template.getInstructionsMap();
+        assertEquals(2, resultInstructions.size());
+        assertTrue(resultInstructions.containsKey("field1"));
+        assertTrue(resultInstructions.containsKey("field2"));
+    }
+
+    @Test
+
+    void testExecute_CompoundField_Logic() throws Exception {
+        // 1. Setup the Type
+        DatasetFieldType compoundType = new DatasetFieldType();
+        compoundType.setName("author");
+        // Since we can't setCompound, we add a child type to make isCompound() return true
+        DatasetFieldType childType = new DatasetFieldType();
+        childType.setName("authorName");
+        compoundType.setChildDatasetFieldTypes(List.of(childType));
+
+        // 2. Setup existing field in Template
+        DatasetField existingField = new DatasetField();
+        existingField.setDatasetFieldType(compoundType);
+
+        // Create an existing compound value
+        DatasetFieldCompoundValue existingValue = new DatasetFieldCompoundValue();
+        existingField.setDatasetFieldCompoundValues(new ArrayList<>(List.of(existingValue)));
+
+        template.getDatasetFields().add(existingField);
+
+        // 3. Setup the Update Command input
+        DatasetField updatedField = new DatasetField();
+        updatedField.setDatasetFieldType(compoundType);
+
+        DatasetFieldCompoundValue newValue = new DatasetFieldCompoundValue();
+        updatedField.setDatasetFieldCompoundValues(List.of(newValue));
+        updatedFields.add(updatedField);
+
+        // We need to spy or mock the display values because 
+        // real display value calculation requires deep child-field nesting
+        DatasetField spyExisting = spy(existingField);
+        DatasetField spyUpdated = spy(updatedField);
+
+        // Scenario: They are different, so newValue should be added
+        doReturn("Author 1").when(spyExisting).getCompoundDisplayValue();
+        doReturn("Author 2").when(spyUpdated).getCompoundDisplayValue();
+
+        // Re-inject the spy into the template fields list
+        template.getDatasetFields().clear();
+        template.getDatasetFields().add(spyExisting);
+
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(
+                template, dataverse, List.of(spyUpdated), instructions, false, request
+        );
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(2, spyExisting.getDatasetFieldCompoundValues().size(),
+                "Should have added the new compound value since display values differed");
+    }
+
+    // Helper to build DatasetFields for testing
+    private DatasetField createPrimitiveField(String typeName, String value) {
+        DatasetField f = new DatasetField();
+        DatasetFieldType type = new DatasetFieldType();
+        type.setChildDatasetFieldTypes(new ArrayList<>());
+        type.setName(typeName);
+        f.setDatasetFieldType(type);
+        f.setSingleValue(value);
+        return f;
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java
new file mode 100644
index 00000000000..b3260525816
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java
@@ -0,0 +1,102 @@
+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.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.TemplateServiceBean;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import edu.harvard.iq.dataverse.license.License;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class UpdateTemplateLicenseCommandTest {
+
+    private UpdateTemplateLicenseCommand cmd;
+
+    @Mock private CommandContext ctxt;
+    @Mock private TemplateServiceBean templateService;
+    @Mock private DataverseRequest request;
+    @Mock private Dataverse dataverse;
+    @Mock private Template template;
+    
+    // We use a real object for terms to verify field mapping easily
+    private TermsOfUseAndAccess existingTerms;
+
+    @BeforeEach
+    void setUp() {
+        existingTerms = new TermsOfUseAndAccess();
+        lenient().when(ctxt.templates()).thenReturn(templateService);
+        lenient().when(template.getTermsOfUseAndAccess()).thenReturn(existingTerms);
+    }
+
+    @Test
+    void testExecute_SuccessWithLicense() throws Exception {
+        // Arrange
+        License activeLicense = mock(License.class);
+        when(activeLicense.isActive()).thenReturn(true);
+        when(templateService.save(template)).thenReturn(template);
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, activeLicense);
+
+        // Act
+        Template result = cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(activeLicense, existingTerms.getLicense());
+        verify(templateService).save(template);
+        assertNotNull(result);
+    }
+
+    @Test
+    void testExecute_InactiveLicenseThrowsException() {
+        // Arrange
+        License inactiveLicense = mock(License.class);
+        when(inactiveLicense.isActive()).thenReturn(false);
+        when(inactiveLicense.getName()).thenReturn("CC BY-NC");
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, inactiveLicense);
+
+        // Act & Assert
+        assertThrows(InvalidCommandArgumentsException.class, () -> cmd.execute(ctxt));
+    }
+
+    @Test
+    void testExecute_SuccessWithCustomTerms() throws Exception {
+        // Arrange
+        TermsOfUseAndAccess customTerms = new TermsOfUseAndAccess();
+        customTerms.setTermsOfUse("My Custom Rules");
+        customTerms.setConfidentialityDeclaration("Top Secret");
+        
+        when(templateService.save(template)).thenReturn(template);
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, customTerms);
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        assertEquals("My Custom Rules", existingTerms.getTermsOfUse());
+        assertEquals("Top Secret", existingTerms.getConfidentialityDeclaration());
+        verify(templateService).save(template);
+    }
+
+    @Test
+    void testExecute_BlankCustomTermsThrowsException() {
+        // Arrange
+        TermsOfUseAndAccess blankTerms = new TermsOfUseAndAccess();
+        blankTerms.setTermsOfUse("   "); // Blank string
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, blankTerms);
+
+        // Act & Assert
+        assertThrows(InvalidCommandArgumentsException.class, () -> cmd.execute(ctxt));
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java
new file mode 100644
index 00000000000..4a9763e7de9
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java
@@ -0,0 +1,86 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+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.InvalidCommandArgumentsException;
+
+import edu.harvard.iq.dataverse.TemplateServiceBean;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class UpdateTemplateTermsOfAccessCommandTest {
+
+    private UpdateTemplateTermsOfAccessCommand cmd;
+
+    @Mock private CommandContext ctxt;
+    @Mock private TemplateServiceBean templateService;
+    @Mock private DataverseRequest request;
+    @Mock private Dataverse dataverse;
+    @Mock private Template template;
+
+    // We'll use real POJOs for the terms to verify the data transfer logic
+    private TermsOfUseAndAccess targetTerms;
+    private TermsOfUseAndAccess sourceTerms;
+
+    @BeforeEach
+    void setUp() {
+        targetTerms = new TermsOfUseAndAccess();
+        sourceTerms = new TermsOfUseAndAccess();
+        
+        // Setup the context to return our mocked service
+        lenient().when(ctxt.templates()).thenReturn(templateService);
+        // Setup the template to return our "target" terms object
+        lenient().when(template.getTermsOfUseAndAccess()).thenReturn(targetTerms);
+    }
+
+    @Test
+    void testExecute_Success() throws Exception {
+        // Arrange: Populate the source with data
+        sourceTerms.setFileAccessRequest(true);
+        sourceTerms.setTermsOfAccess("Special restricted access only.");
+        sourceTerms.setDataAccessPlace("Secure Data Lab");
+        
+        when(templateService.save(template)).thenReturn(template);
+        
+        cmd = new UpdateTemplateTermsOfAccessCommand(request, template, dataverse, sourceTerms);
+
+        // Act
+        Template result = cmd.execute(ctxt);
+
+        // Assert: Verify the target object was updated with source values
+        assertTrue(targetTerms.isFileAccessRequest());
+        assertEquals("Special restricted access only.", targetTerms.getTermsOfAccess());
+        assertEquals("Secure Data Lab", targetTerms.getDataAccessPlace());
+        
+        // Verify interaction
+        verify(templateService).save(template);
+        assertNotNull(result);
+    }
+
+    @Test
+    void testExecute_NullTermsThrowsException() {
+        // Arrange
+        cmd = new UpdateTemplateTermsOfAccessCommand(request, template, dataverse, null);
+
+        // Act & Assert
+        assertThrows(InvalidCommandArgumentsException.class, () -> cmd.execute(ctxt));
+    }
+}
\ No newline at end of file