diff --git a/Octokit.Tests/Http/ApiConnectionTests.cs b/Octokit.Tests/Http/ApiConnectionTests.cs
index d4521c0a..0ca588f4 100644
--- a/Octokit.Tests/Http/ApiConnectionTests.cs
+++ b/Octokit.Tests/Http/ApiConnectionTests.cs
@@ -208,14 +208,14 @@ namespace Octokit.Tests.Http
                 var uploadUrl = new Uri("/anything", UriKind.Relative);
                 IResponse<string> response = new ApiResponse<string> { BodyAsObject = "the response" };
                 var connection = Substitute.For<IConnection>();
-                connection.PostRawAsync<string>(Args.Uri, Arg.Any<Stream>(), Arg.Any<IDictionary<string,string>>()).Returns(Task.FromResult(response));
+                connection.PostAsync<string>(Args.Uri, Arg.Any<Stream>(), Args.String, Args.String)
+                    .Returns(Task.FromResult(response));
                 var apiConnection = new ApiConnection<Boolean>(connection);
                 var rawData = new MemoryStream();
 
                 await apiConnection.Upload<string>(uploadUrl, rawData, "B");
 
-                connection.Received().PostRawAsync<string>(uploadUrl, rawData,
-                    Arg.Any<Dictionary<string, string>>());
+                connection.Received().PostAsync<string>(uploadUrl, rawData, Args.String, Args.String);
             }
 
             [Fact]
diff --git a/Octokit.Tests/Http/ConnectionTests.cs b/Octokit.Tests/Http/ConnectionTests.cs
index c1f2d925..92b14de3 100644
--- a/Octokit.Tests/Http/ConnectionTests.cs
+++ b/Octokit.Tests/Http/ConnectionTests.cs
@@ -270,15 +270,43 @@ namespace Octokit.Tests.Http
                     Substitute.For<IJsonSerializer>());
 
                 var body = new MemoryStream(new byte[] { 48, 49, 50 });
-                var headers = new Dictionary<string, string> { { "Content-Type", "application/arbitrary" } };
-                await connection.PostRawAsync<string>(new Uri("https://other.host.com/path?query=val"), body, headers);
+                await connection.PostAsync<string>(
+                    new Uri("https://other.host.com/path?query=val"),
+                    body,
+                    "application/arbitrary", null);
 
                 httpClient.Received().Send<string>(Arg.Is<IRequest>(req =>
                     req.BaseAddress == ExampleUri &&
                     req.Body == body &&
+                    req.Headers["Accept"] == "application/vnd.github.v3+json; charset=utf-8" &&
+                    req.ContentType == "application/arbitrary" &&
                     req.Method == HttpMethod.Post &&
                     req.Endpoint == new Uri("https://other.host.com/path?query=val")));
             }
+
+            [Fact]
+            public async Task SetsAcceptsHeader()
+            {
+                var httpClient = Substitute.For<IHttpClient>();
+                IResponse<string> response = new ApiResponse<string>();
+                httpClient.Send<string>(Args.Request).Returns(Task.FromResult(response));
+                var connection = new Connection("Test Runner User Agent",
+                    ExampleUri,
+                    Substitute.For<ICredentialStore>(),
+                    httpClient,
+                    Substitute.For<IJsonSerializer>());
+
+                var body = new MemoryStream(new byte[] { 48, 49, 50 });
+                await connection.PostAsync<string>(
+                    new Uri("https://other.host.com/path?query=val"),
+                    body,
+                    null,
+                    "application/json");
+
+                httpClient.Received().Send<string>(Arg.Is<IRequest>(req =>
+                    req.Headers["Accept"] == "application/json" &&
+                    req.ContentType == null));
+            }
         }
 
         public class TheDeleteAsyncMethod
diff --git a/Octokit/Http/ApiConnection.cs b/Octokit/Http/ApiConnection.cs
index 390110d7..1c124fa4 100644
--- a/Octokit/Http/ApiConnection.cs
+++ b/Octokit/Http/ApiConnection.cs
@@ -88,7 +88,7 @@ namespace Octokit.Http
         public async Task Delete(Uri endpoint)
         {
             Ensure.ArgumentNotNull(endpoint, "endpoint");
-            
+
             await Connection.DeleteAsync<T>(endpoint);
         }
 
@@ -98,11 +98,11 @@ namespace Octokit.Http
             Ensure.ArgumentNotNull(rawData, "rawData");
             Ensure.ArgumentNotNull(contentType, "contentType");
 
-            var response = await Connection.PostRawAsync<TOther>(uri, rawData, new Dictionary<string, string> 
-            {
-                { "Content-Type", contentType },
-                { "Accept", "application/vnd.github.manifold-preview" }
-            });
+            var response = await Connection.PostAsync<TOther>(
+                uri,
+                rawData,
+                contentType,
+                "application/vnd.github.manifold-preview");
             return response.BodyAsObject;
         }
 
diff --git a/Octokit/Http/Connection.cs b/Octokit/Http/Connection.cs
index 456cdca4..e9716f13 100644
--- a/Octokit/Http/Connection.cs
+++ b/Octokit/Http/Connection.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
@@ -108,26 +107,12 @@ namespace Octokit.Http
             return await SendData<T>(endpoint, HttpMethod.Post, body);
         }
 
-        public async Task<IResponse<T>> PostRawAsync<T>(Uri endpoint, Stream body, IDictionary<string, string> headers)
+        public async Task<IResponse<T>> PostAsync<T>(Uri endpoint, object body, string contentType, string accepts)
         {
             Ensure.ArgumentNotNull(endpoint, "endpoint");
             Ensure.ArgumentNotNull(body, "body");
-            Ensure.ArgumentNotNull(headers, "headers");
 
-            var request = new Request
-            {
-                Method = HttpMethod.Post,
-                BaseAddress = BaseAddress,
-                Endpoint = endpoint,
-                Body = body
-            };
-            foreach (var header in headers)
-            {
-                request.Headers[header.Key] = header.Value;
-            }
-            var response = await RunRequest<T>(request);
-            _jsonPipeline.DeserializeResponse(response);
-            return response;
+            return await SendData<T>(endpoint, HttpMethod.Post, body, contentType, accepts);
         }
 
         public async Task<IResponse<T>> PutAsync<T>(Uri endpoint, object body)
@@ -139,7 +124,8 @@ namespace Octokit.Http
             Uri endpoint,
             HttpMethod method,
             object body,
-            string contentType = "application/x-www-form-urlencoded" // Per: http://developer.github.com/v3/
+            string contentType = "application/x-www-form-urlencoded", // Per: http://developer.github.com/v3/
+            string accepts = null
         )
         {
             Ensure.ArgumentNotNull(endpoint, "endpoint");
@@ -151,6 +137,11 @@ namespace Octokit.Http
                 Endpoint = endpoint,
             };
 
+            if (!String.IsNullOrEmpty(accepts))
+            {
+                request.Headers["Accept"] = accepts;
+            }
+
             if (body != null)
             {
                 request.Body = body;
diff --git a/Octokit/Http/IConnection.cs b/Octokit/Http/IConnection.cs
index 47a0689c..a350fe5f 100644
--- a/Octokit/Http/IConnection.cs
+++ b/Octokit/Http/IConnection.cs
@@ -12,7 +12,7 @@ namespace Octokit.Http
         Task<IResponse<T>> GetAsync<T>(Uri endpoint, IDictionary<string, string> parameters);
         Task<IResponse<T>> PatchAsync<T>(Uri endpoint, object body);
         Task<IResponse<T>> PostAsync<T>(Uri endpoint, object body);
-        Task<IResponse<T>> PostRawAsync<T>(Uri endpoint, Stream body, IDictionary<string, string> headers);
+        Task<IResponse<T>> PostAsync<T>(Uri endpoint, object body, string contentType, string accepts);
         Task<IResponse<T>> PutAsync<T>(Uri endpoint, object body);
 
         [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]