diff --git a/RestSharp.IntegrationTests/AsyncTests.cs b/RestSharp.IntegrationTests/AsyncTests.cs
index 1951b96c3..29ef61415 100644
--- a/RestSharp.IntegrationTests/AsyncTests.cs
+++ b/RestSharp.IntegrationTests/AsyncTests.cs
@@ -69,7 +69,7 @@ public void Can_Perform_GET_TaskAsync()
 		}
 		
 		[Fact]
-		public void Can_Perform_GET_TaskAsync_With_Response_Type()
+		public void Can_Perform_ExecuteGetTaskAsync_With_Response_Type()
 		{
 			const string baseUrl = "http://localhost:8080/";
 			using (SimpleServer.Create(baseUrl, Handlers.Generic<ResponseHandler>()))
@@ -80,6 +80,22 @@ public void Can_Perform_GET_TaskAsync_With_Response_Type()
 				var task = client.ExecuteTaskAsync<Response>(request);
 				task.Wait();
 
+				Assert.Equal("Works!", task.Result.Data.Message);
+			}
+		}
+
+		[Fact]
+		public void Can_Perform_GetTaskAsync_With_Response_Type()
+		{
+			const string baseUrl = "http://localhost:8080/";
+			using (SimpleServer.Create(baseUrl, Handlers.Generic<ResponseHandler>()))
+			{
+				var client = new RestClient(baseUrl);
+				var request = new RestRequest("success");
+
+				var task = client.GetTaskAsync<Response>(request);
+				task.Wait();
+
 				Assert.Equal("Works!", task.Result.Message);
 			}
 		}
@@ -148,7 +164,7 @@ public void Handles_GET_Request_Errors_TaskAsync_With_Response_Type()
 				var task = client.ExecuteTaskAsync<Response>(request);
 				task.Wait();
 
-				Assert.Null(task.Result);
+				Assert.Null(task.Result.Data);
 			}
 		}
 
diff --git a/RestSharp/IRestClient.cs b/RestSharp/IRestClient.cs
index 476f20c1a..77010f317 100644
--- a/RestSharp/IRestClient.cs
+++ b/RestSharp/IRestClient.cs
@@ -130,21 +130,21 @@ public interface IRestClient
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="token">The cancellation token</param>
-		Task<T> ExecuteTaskAsync<T>(IRestRequest request, CancellationToken token);
+		Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request, CancellationToken token);
 
 		/// <summary>
 		/// Executes the request asynchronously, authenticating if needed
 		/// </summary>
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
-		Task<T> ExecuteTaskAsync<T>(IRestRequest request);
+		Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request);
 
 		/// <summary>
 		/// Executes a GET-style request asynchronously, authenticating if needed
 		/// </summary>
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
-		Task<T> ExecuteGetTaskAsync<T>(IRestRequest request);
+		Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest request);
 
 		/// <summary>
 		/// Executes a GET-style request asynchronously, authenticating if needed
@@ -152,14 +152,14 @@ public interface IRestClient
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="token">The cancellation token</param>
-		Task<T> ExecuteGetTaskAsync<T>(IRestRequest request, CancellationToken token);
+		Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest request, CancellationToken token);
 
 		/// <summary>
 		/// Executes a POST-style request asynchronously, authenticating if needed
 		/// </summary>
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
-		Task<T> ExecutePostTaskAsync<T>(IRestRequest request);
+		Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest request);
 
 		/// <summary>
 		/// Executes a POST-style request asynchronously, authenticating if needed
@@ -167,7 +167,7 @@ public interface IRestClient
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="token">The cancellation token</param>
-		Task<T> ExecutePostTaskAsync<T>(IRestRequest request, CancellationToken token);
+		Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest request, CancellationToken token);
 
 		/// <summary>
 		/// Executes the request and callback asynchronously, authenticating if needed
diff --git a/RestSharp/RestClient.Async.cs b/RestSharp/RestClient.Async.cs
index ae215124a..6b57128fa 100644
--- a/RestSharp/RestClient.Async.cs
+++ b/RestSharp/RestClient.Async.cs
@@ -164,9 +164,9 @@ private void DeserializeResponse<T>(IRestRequest request, Action<IRestResponse<T
 		/// </summary>
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
-		public virtual Task<T> ExecuteGetTaskAsync<T>(IRestRequest request)
+		public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest request)
 		{
-			return this.ExecuteGetTaskAsync<T>(request, CancellationToken.None);
+			return ExecuteGetTaskAsync<T>(request, CancellationToken.None);
 		}
 
 		/// <summary>
@@ -175,7 +175,7 @@ public virtual Task<T> ExecuteGetTaskAsync<T>(IRestRequest request)
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="token">The cancellation token</param>
-		public virtual Task<T> ExecuteGetTaskAsync<T>(IRestRequest request, CancellationToken token)
+		public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest request, CancellationToken token)
 		{
 			if (request == null)
 			{
@@ -191,9 +191,9 @@ public virtual Task<T> ExecuteGetTaskAsync<T>(IRestRequest request, Cancellation
 		/// </summary>
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
-		public virtual Task<T> ExecutePostTaskAsync<T>(IRestRequest request)
+		public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest request)
 		{
-			return this.ExecutePostTaskAsync<T>(request, CancellationToken.None);
+			return ExecutePostTaskAsync<T>(request, CancellationToken.None);
 		}
 
 		/// <summary>
@@ -202,7 +202,7 @@ public virtual Task<T> ExecutePostTaskAsync<T>(IRestRequest request)
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="token">The cancellation token</param>
-		public virtual Task<T> ExecutePostTaskAsync<T>(IRestRequest request, CancellationToken token)
+		public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest request, CancellationToken token)
 		{
 			if (request == null)
 			{
@@ -218,7 +218,7 @@ public virtual Task<T> ExecutePostTaskAsync<T>(IRestRequest request, Cancellatio
 		/// </summary>
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
-		public virtual Task<T> ExecuteTaskAsync<T>(IRestRequest request)
+		public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request)
 		{
 			return ExecuteTaskAsync<T>(request, CancellationToken.None);
 		}
@@ -229,18 +229,18 @@ public virtual Task<T> ExecuteTaskAsync<T>(IRestRequest request)
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="token">The cancellation token</param>
-		public virtual Task<T> ExecuteTaskAsync<T>(IRestRequest request, CancellationToken token)
+		public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request, CancellationToken token)
 		{
 			if (request == null)
 			{
 				throw new ArgumentNullException("request");
 			}
 
-			var taskCompletionSource = new TaskCompletionSource<T>();
+			var taskCompletionSource = new TaskCompletionSource<IRestResponse<T>>();
 
 			try
 			{
-				var async = this.ExecuteAsync<T>(request, (response, _) =>
+				var async = ExecuteAsync<T>(request, (response, _) =>
 					{
 						if (token.IsCancellationRequested)
 						{
@@ -256,7 +256,7 @@ public virtual Task<T> ExecuteTaskAsync<T>(IRestRequest request, CancellationTok
 						}
 						else
 						{
-							taskCompletionSource.TrySetResult(response.Data);
+							taskCompletionSource.TrySetResult(response);
 						}
 					});
 
diff --git a/RestSharp/RestClientExtensions.cs b/RestSharp/RestClientExtensions.cs
index 10f0e96df..c11776c7f 100644
--- a/RestSharp/RestClientExtensions.cs
+++ b/RestSharp/RestClientExtensions.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace RestSharp
 {
@@ -106,11 +107,54 @@ public static RestRequestAsyncHandle PatchAsync(this IRestClient client, IRestRe
 			return client.ExecuteAsync(request, callback);
 		}
 
-        public static RestRequestAsyncHandle DeleteAsync(this IRestClient client, IRestRequest request, Action<IRestResponse, RestRequestAsyncHandle> callback)
-        {
-            request.Method = Method.DELETE;
-            return client.ExecuteAsync(request, callback);
-        }
+		public static RestRequestAsyncHandle DeleteAsync(this IRestClient client, IRestRequest request, Action<IRestResponse, RestRequestAsyncHandle> callback)
+		{
+			request.Method = Method.DELETE;
+			return client.ExecuteAsync(request, callback);
+		}
+
+#if NET4
+		public static Task<T> GetTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			return client.ExecuteGetTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+
+		public static Task<T> PostTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			return client.ExecutePostTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+
+		public static Task<T> PutTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			request.Method = Method.PUT;
+			return client.ExecuteTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+
+		public static Task<T> HeadTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			request.Method = Method.HEAD;
+			return client.ExecuteTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+
+		public static Task<T> OptionsTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			request.Method = Method.OPTIONS;
+			return client.ExecuteTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+
+		public static Task<T> PatchTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			request.Method = Method.PATCH;
+			return client.ExecuteTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+
+		public static Task<T> DeleteTaskAsync<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			request.Method = Method.DELETE;
+			return client.ExecuteTaskAsync<T>(request).ContinueWith(x => x.Result.Data);
+		}
+#endif
+
 #if FRAMEWORK
 		public static IRestResponse<T> Get<T>(this IRestClient client, IRestRequest request) where T : new()
 		{
@@ -148,11 +192,11 @@ public static RestRequestAsyncHandle DeleteAsync(this IRestClient client, IRestR
 			return client.Execute<T>(request);
 		}
 
-        public static IRestResponse<T> Delete<T>(this IRestClient client, IRestRequest request) where T : new()
-        {
-            request.Method = Method.DELETE;
-            return client.Execute<T>(request);
-        }
+		public static IRestResponse<T> Delete<T>(this IRestClient client, IRestRequest request) where T : new()
+		{
+			request.Method = Method.DELETE;
+			return client.Execute<T>(request);
+		}
 
 		public static IRestResponse Get(this IRestClient client, IRestRequest request)
 		{
@@ -190,11 +234,11 @@ public static IRestResponse Patch(this IRestClient client, IRestRequest request)
 			return client.Execute(request);
 		}
 
-        public static IRestResponse Delete(this IRestClient client, IRestRequest request)
-        {
-            request.Method = Method.DELETE;
-            return client.Execute(request);
-        }
+		public static IRestResponse Delete(this IRestClient client, IRestRequest request)
+		{
+			request.Method = Method.DELETE;
+			return client.Execute(request);
+		}
 #endif
 
 		/// <summary>
@@ -214,20 +258,20 @@ public static void AddDefaultParameter(this IRestClient restClient, Parameter p)
 			restClient.DefaultParameters.Add(p);
 		}
 
-        /// <summary>
-        /// Removes a parameter from the default parameters that are used on every request made with this client instance
-        /// </summary>
-        /// <param name="restClient">The IRestClient instance</param>
-        /// <param name="name">The name of the parameter that needs to be removed</param>
-        /// <returns></returns>
-        public static void RemoveDefaultParameter(this IRestClient restClient, string name)
-        {
-            var parameter = restClient.DefaultParameters.SingleOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
-            if (parameter != null)
-            {
-                restClient.DefaultParameters.Remove(parameter);
-            }
-        }
+		/// <summary>
+		/// Removes a parameter from the default parameters that are used on every request made with this client instance
+		/// </summary>
+		/// <param name="restClient">The IRestClient instance</param>
+		/// <param name="name">The name of the parameter that needs to be removed</param>
+		/// <returns></returns>
+		public static void RemoveDefaultParameter(this IRestClient restClient, string name)
+		{
+			var parameter = restClient.DefaultParameters.SingleOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+			if (parameter != null)
+			{
+				restClient.DefaultParameters.Remove(parameter);
+			}
+		}
 
 		/// <summary>
 		/// Adds a HTTP parameter (QueryString for GET, DELETE, OPTIONS and HEAD; Encoded form for POST and PUT)