diff --git a/src/SparkPost.Tests/DataMapperTests.cs b/src/SparkPost.Tests/DataMapperTests.cs
index 3a6e54e3..9faa1f18 100644
--- a/src/SparkPost.Tests/DataMapperTests.cs
+++ b/src/SparkPost.Tests/DataMapperTests.cs
@@ -1307,5 +1307,56 @@ public void limit()
                 Assert.That(dict["limit"].CastTo<int>(), Is.EqualTo(r));
             }
         }
+
+        [TestFixture]
+        public class TemplateMappingTests
+        {
+            private DataMapper _mapper;
+            private Template _template;
+
+            [SetUp]
+            public void Setup()
+            {
+                _template = new Template();
+                _mapper = new DataMapper("v1");
+            }
+
+            [Test]
+            public void has_draft()
+            {
+                bool hasDraftValue = false;
+                _template.HasDraft = hasDraftValue;
+                var dict = _mapper.ToDictionary(_template);
+                Assert.AreEqual(hasDraftValue, dict["has_draft"]);
+            }
+
+            [Test]
+            public void has_published()
+            {
+                bool value = true;
+                _template.HasPublished = value;
+                var dict = _mapper.ToDictionary(_template);
+                Assert.AreEqual(value, dict["has_published"]);
+            }
+
+            [Test]
+            public void has_option_click_tracking()
+            {
+                bool value = true;
+                _template.Options.ClickTracking = value;
+                var dict = _mapper.ToDictionary(_template);
+                var optionsDict = (Dictionary<string, object>)dict["options"];
+                Assert.AreEqual(value, optionsDict["click_tracking"]);
+            }
+
+            [Test]
+            [ExpectedException(typeof(KeyNotFoundException))]
+            public void has_option_click_tracking_null()
+            {
+                var dict = _mapper.ToDictionary(_template);
+                var optionsDict = (Dictionary<string, object>)dict["options"];
+                Assert.AreEqual(true, optionsDict["click_tracking"]);
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/SparkPost.Tests/SparkPost.Tests.csproj b/src/SparkPost.Tests/SparkPost.Tests.csproj
index 5a2d99f7..d002a6e0 100644
--- a/src/SparkPost.Tests/SparkPost.Tests.csproj
+++ b/src/SparkPost.Tests/SparkPost.Tests.csproj
@@ -117,6 +117,7 @@
     <Compile Include="RequestSenders\RequestSenderTests.cs" />
     <Compile Include="SuppressionTests.cs" />
     <Compile Include="RequestSenders\SyncRequestSenderTests.cs" />
+    <Compile Include="TemplateTests.cs" />
     <Compile Include="TransmissionTests.cs" />
     <Compile Include="SubaccountTest.cs" />
     <Compile Include="Utilities\SnakeCaseTests.cs" />
diff --git a/src/SparkPost.Tests/TemplateTests.cs b/src/SparkPost.Tests/TemplateTests.cs
new file mode 100644
index 00000000..4c95f424
--- /dev/null
+++ b/src/SparkPost.Tests/TemplateTests.cs
@@ -0,0 +1,207 @@
+using AutoMoq.Helpers;
+using Moq;
+using NUnit.Framework;
+using Should;
+using SparkPost.RequestSenders;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace SparkPost.Tests
+{
+    public class TemplateTests
+    {
+        [TestFixture]
+        public class DeleteTests : AutoMoqTestFixture<Templates>
+        {
+            private Response _response;
+            private Template _template;
+
+            [SetUp]
+            public void Setup()
+            {
+                ResetSubject();
+
+                _response = new Response { StatusCode = HttpStatusCode.NoContent };
+
+                Mocked<IRequestSender>()
+                    .Setup(x => x.Send(It.IsAny<Request>()))
+                    .Returns(Task.FromResult(_response));
+
+                _template = new Template()
+                {
+                    Id = Guid.NewGuid().ToString()
+                };
+            }
+
+            [Test]
+            public async void It_should_return_false_if_the_status_is_not_ok()
+            {
+                var result = await Subject.Delete(_template.Id);
+                result.ShouldBeFalse();
+            }
+
+            [Test]
+            public async void It_should_return_false_if_the_web_request_returns_anything_but_no_content()
+            {
+                _response.StatusCode = HttpStatusCode.Accepted;
+                (await Subject.Delete(_template.Id)).ShouldBeFalse();
+
+                _response.StatusCode = HttpStatusCode.Ambiguous;
+                (await Subject.Delete(_template.Id)).ShouldBeFalse();
+
+                _response.StatusCode = HttpStatusCode.UpgradeRequired;
+                (await Subject.Delete(_template.Id)).ShouldBeFalse();
+            }
+
+            [Test]
+            public async void It_should_build_the_web_request_parameters_correctly()
+            {
+                var version = Guid.NewGuid().ToString();
+
+                Mocked<IClient>()
+                    .Setup(x => x.Version)
+                    .Returns(version);
+
+                Mocked<IRequestSender>()
+                    .Setup(x => x.Send(It.IsAny<Request>()))
+                    .Callback((Request r) =>
+                    {
+                        r.Url.ShouldEqual($"api/{version}/templates/{_template.Id}");
+                        r.Method.ShouldEqual("DELETE");
+                    })
+                    .Returns(Task.FromResult(_response));
+
+                await Subject.Delete(_template.Id);
+            }
+        }
+
+        [TestFixture]
+        public class CreateOrUpdateTests : AutoMoqTestFixture<Templates>
+        {
+            private Response _response;
+            private List<Template> _templates;
+
+            [SetUp]
+            public void Setup()
+            {
+                ResetSubject();
+
+                _response = new Response
+                {
+                    StatusCode = HttpStatusCode.OK,
+                    Content = ""
+                };
+
+                Mocked<IRequestSender>()
+                    .Setup(x => x.Send(It.IsAny<Request>()))
+                    .Returns(Task.FromResult(_response));
+
+                _templates = new List<Template>
+                {
+                    new Template(),
+                    new Template()
+                };
+            }
+
+            [Test]
+            public async void It_should_return_a_response_when_the_web_request_is_ok()
+            {
+                var result = await Subject.Create(_templates[0]);
+                result.ShouldNotBeNull();
+
+                var boolResult = await Subject.Update(_templates[0].Id, _templates[0]);
+                Assert.AreEqual(true, boolResult);
+            }
+
+            [Test]
+            public async void It_should_return_the_reason_phrase()
+            {
+                _response.ReasonPhrase = Guid.NewGuid().ToString();
+                var result = await Subject.Create(_templates[0]);
+                result.ReasonPhrase.ShouldEqual(_response.ReasonPhrase);
+            }
+
+            [Test]
+            public async void It_should_return_the_content()
+            {
+                _response.Content = Guid.NewGuid().ToString();
+                var result = await Subject.Create(_templates[1]);
+                result.Content.ShouldEqual(_response.Content);
+            }
+
+            [Test]
+            public async void It_should_make_a_properly_formed_request_for_create()
+            {
+                var client = Mocked<IClient>().Object;
+                Mocked<IClient>().Setup(x => x.Version).Returns(Guid.NewGuid().ToString());
+                Mocked<IRequestSender>()
+                    .Setup(x => x.Send(It.IsAny<Request>()))
+                    .Callback((Request r) =>
+                    {
+                        r.Url.ShouldEqual($"api/{client.Version}/templates");
+                        r.Method.ShouldEqual("POST");
+                    })
+                    .Returns(Task.FromResult(_response));
+
+                await Subject.Create(_templates[1]);
+            }
+
+            [Test]
+            public async void It_should_make_a_properly_formed_request_for_update()
+            {
+                _templates[1].Id = Guid.NewGuid().ToString();
+
+                var client = Mocked<IClient>().Object;
+                Mocked<IClient>().Setup(x => x.Version).Returns(Guid.NewGuid().ToString());
+                Mocked<IRequestSender>()
+                    .Setup(x => x.Send(It.IsAny<Request>()))
+                    .Callback((Request r) =>
+                    {
+                        r.Url.ShouldEqual($"api/{client.Version}/templates/{_templates[1].Id}");
+                        r.Method.ShouldEqual("PUT");
+                    })
+                    .Returns(Task.FromResult(_response));
+
+                await Subject.Update(_templates[1].Id, _templates[1]);
+            }
+
+            [Test]
+            public async void It_should_throw_if_the_http_status_code_is_not_ok_for_create()
+            {
+                _response.StatusCode = HttpStatusCode.Accepted;
+
+                Exception exception = null;
+                try
+                {
+                    await Subject.Create(_templates[1]);
+                }
+                catch (ResponseException ex)
+                {
+                    exception = ex;
+                }
+
+                exception.ShouldNotBeNull();
+            }
+
+            [Test]
+            public async void It_should_throw_if_the_http_status_code_is_not_ok_for_update()
+            {
+                _response.StatusCode = HttpStatusCode.Accepted;
+
+                Exception exception = null;
+                try
+                {
+                    await Subject.Update(_templates[1].Id, _templates[1]);
+                }
+                catch (ResponseException ex)
+                {
+                    exception = ex;
+                }
+
+                exception.ShouldNotBeNull();
+            }
+        }
+    }
+}
diff --git a/src/SparkPost/ITemplates.cs b/src/SparkPost/ITemplates.cs
index c3cf8302..d1df7acc 100644
--- a/src/SparkPost/ITemplates.cs
+++ b/src/SparkPost/ITemplates.cs
@@ -25,5 +25,14 @@ public interface ITemplates
         Task<RetrieveTemplatesResponse> List();
 
         Task<bool> Delete(string templateId);
+
+        /// <summary>
+        /// Updates an email template.
+        /// </summary>
+        /// <param name="templateId">The id of the template to update.</param>
+        /// <param name="template">The properties of the template to update. Exclude ID from update</param>
+        /// <param name="updatePublished">If true, updates the most recent published template. If the query param is not passed or set to false, it will result in an update to the draft version.</param>
+        /// <returns>The response from the API.</returns>
+        Task<bool> Update(string templateId, Template template, bool? updatePublished = null);
     }
 }
diff --git a/src/SparkPost/RetrieveTemplateResponse.cs b/src/SparkPost/RetrieveTemplateResponse.cs
index f1ce051b..f60ff527 100644
--- a/src/SparkPost/RetrieveTemplateResponse.cs
+++ b/src/SparkPost/RetrieveTemplateResponse.cs
@@ -18,6 +18,8 @@ public RetrieveTemplateResponse()
         public string Name { get; set; }
         public string Description { get; set; }
         public bool Published { get; set; }
+        public bool HasDraft { get; set; }
+        public bool HasPublished { get; set; }
         public DateTime LastUpdateTime { get; set; }
         public DateTime? LastUse { get; set; }
         public TemplateOptions Options { get; set; }
diff --git a/src/SparkPost/Template.cs b/src/SparkPost/Template.cs
index d94e50bc..bf5ae3c9 100644
--- a/src/SparkPost/Template.cs
+++ b/src/SparkPost/Template.cs
@@ -27,5 +27,7 @@ public class TemplateBase
         public string Name { get; set; }
         public string Description { get; set; }
         public bool Published { get; set; }
+        public bool HasDraft { get; set; }
+        public bool HasPublished { get; set; }
     }
 }
diff --git a/src/SparkPost/Templates.cs b/src/SparkPost/Templates.cs
index c12a17bb..5760698a 100644
--- a/src/SparkPost/Templates.cs
+++ b/src/SparkPost/Templates.cs
@@ -9,11 +9,11 @@ namespace SparkPost
 {
     public class Templates : ITemplates
     {
-        private readonly Client client;
+        private readonly IClient client;
         private readonly IRequestSender requestSender;
-        private readonly DataMapper dataMapper;
+        private readonly IDataMapper dataMapper;
 
-        public Templates(Client client, RequestSender requestSender, DataMapper dataMapper)
+        public Templates(IClient client, IRequestSender requestSender, IDataMapper dataMapper)
         {
             this.client = client;
             this.requestSender = requestSender;
@@ -32,14 +32,24 @@ public async Task<CreateTemplateResponse> Create(Template template)
             var response = await requestSender.Send(request);
             if (response.StatusCode != HttpStatusCode.OK) throw new ResponseException(response);
 
-            var results = JsonConvert.DeserializeObject<dynamic>(response.Content).results;
-            return new CreateTemplateResponse()
+            var createTemplateResponse = new CreateTemplateResponse()
             {
-                Id = results.id,
                 ReasonPhrase = response.ReasonPhrase,
                 StatusCode = response.StatusCode,
                 Content = response.Content
             };
+
+            try
+            {
+                var results = JsonConvert.DeserializeObject<dynamic>(response.Content).results;
+                createTemplateResponse.Id = results.Id;
+            }
+            catch
+            {
+                // ignored.
+            }
+
+            return createTemplateResponse;
         }
 
         public async Task<RetrieveTemplateResponse> Retrieve(string templateId, bool? draft = null)
@@ -60,7 +70,7 @@ public async Task<RetrieveTemplateResponse> Retrieve(string templateId, bool? dr
             if (response.StatusCode != HttpStatusCode.OK) throw new ResponseException(response);
 
             var results = JsonConvert.DeserializeObject<dynamic>(response.Content).results;
-            
+
             Dictionary<string, string> Headers = new Dictionary<string, string>();
             if (results.content.headers != null)
             {
@@ -81,6 +91,8 @@ public async Task<RetrieveTemplateResponse> Retrieve(string templateId, bool? dr
                 Published = results.published,
                 LastUpdateTime = results.last_update_time,
                 LastUse = (results.last_use == null) ? null : results.last_use,
+                HasDraft = results.has_draft,
+                HasPublished = results.has_published,
                 Options = new TemplateOptions()
                 {
                     ClickTracking = results.options.click_tracking,
@@ -124,7 +136,9 @@ public async Task<RetrieveTemplatesResponse> List()
                     Name = result.name,
                     LastUpdateTime = result.last_update_time,
                     Description = result.description,
-                    Published = result.published
+                    Published = result.published,
+                    HasDraft = result.has_draft,
+                    HasPublished = result.has_published
                 });
 
             return new RetrieveTemplatesResponse
@@ -147,5 +161,25 @@ public async Task<bool> Delete(string templateId)
             var response = await requestSender.Send(request);
             return response.StatusCode == HttpStatusCode.OK;
         }
+
+        public async Task<bool> Update(string templateId, Template template, bool? updatePublished = null)
+        {
+            var request = new Request
+            {
+                Url = $"api/{client.Version}/templates/{templateId}",
+                Method = "PUT",
+                Data = dataMapper.ToDictionary(template)
+            };
+
+            if (updatePublished != null)
+            {
+                string updatePublishedValue = updatePublished.ToString().ToLower();
+                request.Url += $"?update_published={updatePublishedValue}";
+            }
+
+            var response = await requestSender.Send(request);
+            if (response.StatusCode != HttpStatusCode.OK) throw new ResponseException(response);
+            return true;
+        }
     }
 }