diff --git a/CHANGELOG.md b/CHANGELOG.md
index d48fe972d..19bcbac11 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 
 ### Bug Fixes
 1. [#106](https://github.com/influxdata/influxdb-client-csharp/pull/106): Fixed serialization of `\n`, `\r` and `\t` to Line Protocol, `=` is valid sign for measurement name  
+1. [#108](https://github.com/influxdata/influxdb-client-csharp/issues/108): Replaced useless .ContinueWith in Api by direct call
 
 ## 1.9.0 [2020-06-19]
 
diff --git a/Client.Legacy/FluxClient.cs b/Client.Legacy/FluxClient.cs
index f0e4cd5f1..1e8a64307 100644
--- a/Client.Legacy/FluxClient.cs
+++ b/Client.Legacy/FluxClient.cs
@@ -389,9 +389,9 @@ public async Task<string> VersionAsync()
         {
             try
             {
-                var response = ExecuteAsync(PingRequest());
+                var response = await ExecuteAsync(PingRequest());
 
-                return await response.ContinueWith(t => GetVersion(t.Result));
+                return GetVersion(response);
             }
             catch (Exception e)
             {
diff --git a/Client.Test/ItBucketsApiTest.cs b/Client.Test/ItBucketsApiTest.cs
index 9d3365cfb..9067604ab 100644
--- a/Client.Test/ItBucketsApiTest.cs
+++ b/Client.Test/ItBucketsApiTest.cs
@@ -69,8 +69,8 @@ public void CloneBucketNotFound()
             var ioe = Assert.ThrowsAsync<AggregateException>(async () =>
                 await _bucketsApi.CloneBucketAsync(GenerateName("bucket"), "020f755c3c082000"));
 
-            Assert.AreEqual(typeof(HttpException), ioe.InnerException.InnerException.GetType());
-            Assert.AreEqual("bucket not found", ioe.InnerException.InnerException.Message);
+            Assert.AreEqual(typeof(HttpException), ioe.InnerException?.GetType());
+            Assert.AreEqual("bucket not found", ioe.InnerException?.Message);
         }
 
         [Test]
diff --git a/Client.Test/ItLabelsApiTest.cs b/Client.Test/ItLabelsApiTest.cs
index f0c21ea3c..81a12ee3a 100644
--- a/Client.Test/ItLabelsApiTest.cs
+++ b/Client.Test/ItLabelsApiTest.cs
@@ -50,8 +50,8 @@ public void CloneLabelNotFound()
                 Assert.ThrowsAsync<AggregateException>(async () => await _labelsApi.CloneLabelAsync(GenerateName("bucket"), "020f755c3c082000"));
 
             Assert.IsNotNull(exception);
-            Assert.AreEqual(typeof(HttpException), exception.InnerException.InnerException.GetType());
-            Assert.AreEqual("label not found", exception.InnerException.InnerException.Message);
+            Assert.AreEqual(typeof(HttpException), exception.InnerException.GetType());
+            Assert.AreEqual("label not found", exception.InnerException.Message);
         }
 
         [Test]
@@ -99,11 +99,11 @@ public async Task DeleteLabel()
             // delete user
             await _labelsApi.DeleteLabelAsync(createdLabel);
 
-            var exception = Assert.ThrowsAsync<AggregateException>(async () => await _labelsApi.FindLabelByIdAsync(createdLabel.Id));
+            var exception = Assert.ThrowsAsync<HttpException>(async () => await _labelsApi.FindLabelByIdAsync(createdLabel.Id));
 
             Assert.IsNotNull(exception);
-            Assert.AreEqual("label not found", exception.InnerException.Message);
-            Assert.AreEqual(typeof(HttpException), exception.InnerException.GetType());
+            Assert.AreEqual("label not found", exception.Message);
+            Assert.AreEqual(typeof(HttpException), exception.GetType());
         }
 
         [Test]
@@ -122,11 +122,11 @@ public async Task FindLabelById()
         [Test]
         public void FindLabelByIdNull()
         {
-            var exception = Assert.ThrowsAsync<AggregateException>(async () => await _labelsApi.FindLabelByIdAsync("020f755c3c082000"));
+            var exception = Assert.ThrowsAsync<HttpException>(async () => await _labelsApi.FindLabelByIdAsync("020f755c3c082000"));
 
             Assert.IsNotNull(exception);
-            Assert.AreEqual("label not found", exception.InnerException.Message);
-            Assert.AreEqual(typeof(HttpException), exception.InnerException.GetType());
+            Assert.AreEqual("label not found", exception.Message);
+            Assert.AreEqual(typeof(HttpException), exception.GetType());
         }
 
         [Test]
diff --git a/Client.Test/ItNotificationEndpointsApiTest.cs b/Client.Test/ItNotificationEndpointsApiTest.cs
index 60d320af7..8fc617f9f 100644
--- a/Client.Test/ItNotificationEndpointsApiTest.cs
+++ b/Client.Test/ItNotificationEndpointsApiTest.cs
@@ -431,27 +431,27 @@ public void CloneNotFound()
             var ioe = Assert.ThrowsAsync<AggregateException>(async () => await _notificationEndpointsApi
                 .CloneSlackEndpointAsync("not-found-cloned", "token", "020f755c3c082000"));
 
-            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.InnerException?.Message);
+            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.Message);
 
             ioe = Assert.ThrowsAsync<AggregateException>(async () => await _notificationEndpointsApi
                 .ClonePagerDutyEndpointAsync("not-found-cloned", "token", "020f755c3c082000"));
 
-            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.InnerException?.Message);
+            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.Message);
 
             ioe = Assert.ThrowsAsync<AggregateException>(async () => await _notificationEndpointsApi
                 .CloneHttpEndpointAsync("not-found-cloned", "020f755c3c082000"));
 
-            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.InnerException?.Message);
+            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.Message);
 
             ioe = Assert.ThrowsAsync<AggregateException>(async () => await _notificationEndpointsApi
                 .CloneHttpEndpointBearerAsync("not-found-cloned", "token", "020f755c3c082000"));
 
-            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.InnerException?.Message);
+            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.Message);
 
             ioe = Assert.ThrowsAsync<AggregateException>(async () => await _notificationEndpointsApi
                 .CloneHttpEndpointBasicAuthAsync("not-found-cloned", "username", "password", "020f755c3c082000"));
 
-            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.InnerException?.Message);
+            Assert.AreEqual("notification endpoint not found for key \"020f755c3c082000\"", ioe.InnerException?.Message);
         }
 
         [Test]
diff --git a/Client.Test/ItSourcesApiTest.cs b/Client.Test/ItSourcesApiTest.cs
index 90bc6cf0a..7fc1de49c 100644
--- a/Client.Test/ItSourcesApiTest.cs
+++ b/Client.Test/ItSourcesApiTest.cs
@@ -137,12 +137,12 @@ public async Task FindBucketsBySource()
         [Test]
         public void FindBucketsBySourceByUnknownSource()
         {
-            var nfe = Assert.ThrowsAsync<AggregateException>(async () =>
+            var nfe = Assert.ThrowsAsync<HttpException>(async () =>
                 await _sourcesApi.FindBucketsBySourceIdAsync("020f755c3d082000"));
 
             Assert.IsNotNull(nfe);
-            Assert.AreEqual("source not found", nfe.InnerException.Message);
-            Assert.AreEqual(typeof(HttpException), nfe.InnerException.GetType());
+            Assert.AreEqual("source not found", nfe.Message);
+            Assert.AreEqual(typeof(HttpException), nfe.GetType());
         }
 
         [Test]
diff --git a/Client.Test/ItTasksApiTest.cs b/Client.Test/ItTasksApiTest.cs
index b048451ea..205658249 100644
--- a/Client.Test/ItTasksApiTest.cs
+++ b/Client.Test/ItTasksApiTest.cs
@@ -331,10 +331,10 @@ public async Task GetLogs()
         [Test]
         public void GetLogsNotExist()
         {
-            var ioe = Assert.ThrowsAsync<AggregateException>(async () => await _tasksApi.GetLogsAsync("020f755c3c082000"));
+            var ioe = Assert.ThrowsAsync<HttpException>(async () => await _tasksApi.GetLogsAsync("020f755c3c082000"));
 
-            Assert.NotNull(ioe.InnerException, "ioe.InnerException != null");
-            Assert.AreEqual("failed to find task logs: task not found", ioe.InnerException.Message);
+            Assert.NotNull(ioe, "ioe.InnerException != null");
+            Assert.AreEqual("failed to find task logs: task not found", ioe.Message);
         }
 
         [Test]
@@ -372,10 +372,10 @@ public async Task GetRunLogsNotExist()
         {
             var task = await _tasksApi.CreateTaskEveryAsync(GenerateName("it task"), TaskFlux, "1s", _organization);
 
-            var ioe = Assert.ThrowsAsync<AggregateException>(async () => await _tasksApi.GetRunLogsAsync(task.Id, "020f755c3c082000"));
+            var ioe = Assert.ThrowsAsync<HttpException>(async () => await _tasksApi.GetRunLogsAsync(task.Id, "020f755c3c082000"));
 
-            Assert.NotNull(ioe.InnerException, "ioe.InnerException != null");
-            Assert.AreEqual("failed to find task logs: run not found", ioe.InnerException.Message);
+            Assert.NotNull(ioe, "ioe.InnerException != null");
+            Assert.AreEqual("failed to find task logs: run not found", ioe.Message);
         }
 
         [Test]
@@ -570,11 +570,11 @@ public async Task RunsLimit()
         [Test]
         public void RunsNotExist()
         {
-            var ioe = Assert.ThrowsAsync<AggregateException>(async () =>
+            var ioe = Assert.ThrowsAsync<HttpException>(async () =>
                 await _tasksApi.GetRunsAsync("020f755c3c082000", _organization.Id));
 
-            Assert.NotNull(ioe.InnerException, "ioe.InnerException != null");
-            Assert.AreEqual("failed to find runs: task not found", ioe.InnerException.Message);
+            Assert.NotNull(ioe, "ioe.InnerException != null");
+            Assert.AreEqual("failed to find runs: task not found", ioe.Message);
         }
 
         [Test]
diff --git a/Client.Test/ItUsersApiTest.cs b/Client.Test/ItUsersApiTest.cs
index 09992a2b4..8a01f4384 100644
--- a/Client.Test/ItUsersApiTest.cs
+++ b/Client.Test/ItUsersApiTest.cs
@@ -84,7 +84,7 @@ public async Task FindUsers()
 
             var users = await _usersApi.FindUsersAsync();
 
-            Assert.AreEqual(users.Count, size + 1);
+            Assert.AreEqual(size + 1, users.Count);
         }
 
         [Test]
diff --git a/Client/AuthorizationsApi.cs b/Client/AuthorizationsApi.cs
index a92b5c970..b1a31911f 100644
--- a/Client/AuthorizationsApi.cs
+++ b/Client/AuthorizationsApi.cs
@@ -186,8 +186,7 @@ public async Task<List<Authorization>> FindAuthorizationsByUserNameAsync(string
 
         private async Task<List<Authorization>> FindAuthorizationsByAsync(string userId, string userName)
         {
-            return await _service.GetAuthorizationsAsync(null, userId, userName)
-                .ContinueWith(t => t.Result._Authorizations);
+            return (await _service.GetAuthorizationsAsync(null, userId, userName))._Authorizations;
         }
     }
 }
\ No newline at end of file
diff --git a/Client/BucketsApi.cs b/Client/BucketsApi.cs
index 6a9404cbb..128872efe 100644
--- a/Client/BucketsApi.cs
+++ b/Client/BucketsApi.cs
@@ -155,7 +155,7 @@ public async Task<Bucket> CloneBucketAsync(string clonedName, string bucketId)
             Arguments.CheckNonEmptyString(clonedName, nameof(clonedName));
             Arguments.CheckNonEmptyString(bucketId, nameof(bucketId));
 
-            return await FindBucketByIdAsync(bucketId).ContinueWith(t => t.Result)
+            return await FindBucketByIdAsync(bucketId)
                 .ContinueWith(t => CloneBucketAsync(clonedName, t.Result)).Unwrap();
         }
 
@@ -209,9 +209,8 @@ public async Task<Bucket> FindBucketByNameAsync(string bucketName)
         {
             Arguments.CheckNonEmptyString(bucketName, nameof(bucketName));
 
-            return await _service
-                .GetBucketsAsync(null, null, null, null, null, bucketName)
-                .ContinueWith(t => t.Result._Buckets.FirstOrDefault());
+            return (await _service.GetBucketsAsync(null, null, null, null, null, bucketName))
+                ._Buckets.FirstOrDefault();
         }
 
         /// <summary>
@@ -233,9 +232,7 @@ public async Task<List<Bucket>> FindBucketsByOrganizationAsync(Organization orga
         /// <returns>A list of buckets</returns>
         public async Task<List<Bucket>> FindBucketsByOrgNameAsync(string orgName)
         {
-            var buckets = FindBucketsAsync(orgName, new FindOptions());
-
-            return await buckets.ContinueWith(t => t.Result._Buckets);
+            return (await FindBucketsAsync(orgName, new FindOptions()))._Buckets;
         }
 
         /// <summary>
@@ -280,7 +277,7 @@ public async Task<List<ResourceMember>> GetMembersAsync(string bucketId)
         {
             Arguments.CheckNonEmptyString(bucketId, nameof(bucketId));
 
-            return await _service.GetBucketsIDMembersAsync(bucketId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetBucketsIDMembersAsync(bucketId)).Users;
         }
 
         /// <summary>
@@ -362,7 +359,7 @@ public async Task<List<ResourceOwner>> GetOwnersAsync(string bucketId)
         {
             Arguments.CheckNonEmptyString(bucketId, nameof(bucketId));
 
-            return await _service.GetBucketsIDOwnersAsync(bucketId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetBucketsIDOwnersAsync(bucketId)).Users;
         }
 
         /// <summary>
@@ -444,7 +441,7 @@ public async Task<List<Label>> GetLabelsAsync(string bucketId)
         {
             Arguments.CheckNonEmptyString(bucketId, nameof(bucketId));
 
-            return await _service.GetBucketsIDLabelsAsync(bucketId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetBucketsIDLabelsAsync(bucketId)).Labels;
         }
 
         /// <summary>
@@ -474,7 +471,7 @@ public async Task<Label> AddLabelAsync(string labelId, string bucketId)
 
             var mapping = new LabelMapping(labelId);
 
-            return await _service.PostBucketsIDLabelsAsync(bucketId, mapping).ContinueWith(t => t.Result.Label);
+            return (await _service.PostBucketsIDLabelsAsync(bucketId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/ChecksApi.cs b/Client/ChecksApi.cs
index 6bd42ca7a..e316ad28e 100644
--- a/Client/ChecksApi.cs
+++ b/Client/ChecksApi.cs
@@ -187,8 +187,7 @@ public async Task<List<Check>> FindChecksAsync(string orgId)
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await FindChecksAsync(orgId, new FindOptions())
-                .ContinueWith(t => t.Result._Checks);
+            return (await FindChecksAsync(orgId, new FindOptions()))._Checks;
         }
 
         /// <summary>
@@ -227,7 +226,7 @@ public async Task<List<Label>> GetLabelsAsync(string checkId)
         {
             Arguments.CheckNonEmptyString(checkId, nameof(checkId));
 
-            return await _service.GetChecksIDLabelsAsync(checkId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetChecksIDLabelsAsync(checkId)).Labels;
         }
 
         /// <summary>
@@ -257,8 +256,7 @@ public async Task<Label> AddLabelAsync(string labelId, string checkId)
 
             var mapping = new LabelMapping(labelId);
 
-            return await _service.PostChecksIDLabelsAsync(checkId, mapping)
-                .ContinueWith(t => t.Result.Label);
+            return (await _service.PostChecksIDLabelsAsync(checkId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/InfluxDBClient.cs b/Client/InfluxDBClient.cs
index 7b29a3599..bd05bc075 100644
--- a/Client/InfluxDBClient.cs
+++ b/Client/InfluxDBClient.cs
@@ -417,9 +417,9 @@ public async Task<OnboardingResponse> OnboardingAsync(OnboardingRequest onboardi
         /// <returns>True if onboarding has already been completed otherwise false</returns>
         public async Task<bool> IsOnboardingAllowedAsync()
         {
-            var isOnboardingAllowed = _setupService.GetSetupAsync().ContinueWith(t => t.Result.Allowed == true);
+            var isOnboarding = await _setupService.GetSetupAsync();
 
-            return await isOnboardingAllowed;
+            return isOnboarding.Allowed == true;
         }
 
         internal static string AuthorizationHeader(string username, string password)
diff --git a/Client/LabelsApi.cs b/Client/LabelsApi.cs
index 167b7f7f7..2da1561d4 100644
--- a/Client/LabelsApi.cs
+++ b/Client/LabelsApi.cs
@@ -27,7 +27,7 @@ public async Task<Label> CreateLabelAsync(LabelCreateRequest request)
         {
             Arguments.CheckNotNull(request, nameof(request));
 
-            return await _service.PostLabelsAsync(request).ContinueWith(t=> t.Result.Label);
+            return (await _service.PostLabelsAsync(request)).Label;
         }
 
         /// <summary>
@@ -69,7 +69,7 @@ public async Task<Label> UpdateLabelAsync(Label label)
         /// <returns>Updated label</returns>
         public async Task<Label> UpdateLabelAsync(string labelId, LabelUpdate labelUpdate)
         {
-            return await _service.PatchLabelsIDAsync(labelId, labelUpdate).ContinueWith(t => t.Result.Label);
+            return (await _service.PatchLabelsIDAsync(labelId, labelUpdate)).Label;
         }
 
         /// <summary>
@@ -107,7 +107,8 @@ public async Task<Label> CloneLabelAsync(string clonedName, string labelId)
             Arguments.CheckNonEmptyString(clonedName, nameof(clonedName));
             Arguments.CheckNonEmptyString(labelId, nameof(labelId));
 
-            return await FindLabelByIdAsync(labelId).ContinueWith(t => CloneLabelAsync(clonedName, t.Result)).Unwrap();
+            return await FindLabelByIdAsync(labelId)
+                            .ContinueWith(t => CloneLabelAsync(clonedName, t.Result)).Unwrap();
         }
 
         /// <summary>
@@ -136,7 +137,7 @@ public async Task<Label> FindLabelByIdAsync(string labelId)
         {
             Arguments.CheckNonEmptyString(labelId, nameof(labelId));
 
-            return await _service.GetLabelsIDAsync(labelId).ContinueWith(t => t.Result.Label);
+            return (await _service.GetLabelsIDAsync(labelId)).Label;
         }
 
         /// <summary>
@@ -145,7 +146,7 @@ public async Task<Label> FindLabelByIdAsync(string labelId)
         /// <returns>List all labels.</returns>
         public async Task<List<Label>> FindLabelsAsync()
         {
-            return await _service.GetLabelsAsync().ContinueWith(t => t.Result.Labels);
+            return (await _service.GetLabelsAsync()).Labels;
         }
 
         /// <summary>
@@ -167,7 +168,7 @@ public async Task<List<Label>> FindLabelsByOrgAsync(Organization organization)
         /// <returns>all labels</returns>
         public async Task<List<Label>> FindLabelsByOrgIdAsync(string orgId)
         {
-            return await _service.GetLabelsAsync(null, orgId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetLabelsAsync(null, orgId)).Labels;
         }
     }
 }
\ No newline at end of file
diff --git a/Client/NotificationEndpointsApi.cs b/Client/NotificationEndpointsApi.cs
index 0547a50ee..dd9d7116c 100644
--- a/Client/NotificationEndpointsApi.cs
+++ b/Client/NotificationEndpointsApi.cs
@@ -236,8 +236,7 @@ public async Task<List<NotificationEndpoint>> FindNotificationEndpointsAsync(str
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await FindNotificationEndpointsAsync(orgId, new FindOptions())
-                .ContinueWith(t => t.Result._NotificationEndpoints);
+            return (await FindNotificationEndpointsAsync(orgId, new FindOptions()))._NotificationEndpoints;
         }
 
         /// <summary>
@@ -280,7 +279,7 @@ public async Task<SlackNotificationEndpoint> CloneSlackEndpointAsync(string name
             Arguments.CheckNonEmptyString(name, nameof(name));
             Arguments.CheckNonEmptyString(endpointId, nameof(endpointId));
 
-            return await FindNotificationEndpointByIdAsync(endpointId).ContinueWith(t => t.Result)
+            return await FindNotificationEndpointByIdAsync(endpointId)
                 .ContinueWith(t => CloneSlackEndpointAsync(name, token, t.Result as SlackNotificationEndpoint))
                 .Unwrap();
         }
@@ -317,7 +316,7 @@ public async Task<PagerDutyNotificationEndpoint> ClonePagerDutyEndpointAsync(str
             Arguments.CheckNonEmptyString(routingKey, nameof(routingKey));
             Arguments.CheckNonEmptyString(endpointId, nameof(endpointId));
 
-            return await FindNotificationEndpointByIdAsync(endpointId).ContinueWith(t => t.Result)
+            return await FindNotificationEndpointByIdAsync(endpointId)
                 .ContinueWith(t =>
                     ClonePagerDutyEndpointAsync(name, routingKey, t.Result as PagerDutyNotificationEndpoint)).Unwrap();
         }
@@ -352,7 +351,7 @@ public async Task<HTTPNotificationEndpoint> CloneHttpEndpointAsync(string name,
             Arguments.CheckNonEmptyString(name, nameof(name));
             Arguments.CheckNonEmptyString(endpointId, nameof(endpointId));
 
-            return await FindNotificationEndpointByIdAsync(endpointId).ContinueWith(t => t.Result)
+            return await FindNotificationEndpointByIdAsync(endpointId)
                 .ContinueWith(t => CloneHttpEndpoint(name, t.Result as HTTPNotificationEndpoint)).Unwrap();
         }
 
@@ -390,7 +389,7 @@ public async Task<HTTPNotificationEndpoint> CloneHttpEndpointBasicAuthAsync(stri
             Arguments.CheckNonEmptyString(password, nameof(password));
             Arguments.CheckNonEmptyString(endpointId, nameof(endpointId));
 
-            return await FindNotificationEndpointByIdAsync(endpointId).ContinueWith(t => t.Result)
+            return await FindNotificationEndpointByIdAsync(endpointId)
                 .ContinueWith(t =>
                     CloneHttpEndpointBasicAuthAsync(name, username, password, t.Result as HTTPNotificationEndpoint))
                 .Unwrap();
@@ -435,7 +434,7 @@ public async Task<HTTPNotificationEndpoint> CloneHttpEndpointBearerAsync(string
             Arguments.CheckNonEmptyString(token, nameof(token));
             Arguments.CheckNonEmptyString(endpointId, nameof(endpointId));
 
-            return await FindNotificationEndpointByIdAsync(endpointId).ContinueWith(t => t.Result)
+            return await FindNotificationEndpointByIdAsync(endpointId)
                 .ContinueWith(t =>
                     CloneHttpEndpointBearerAsync(name, token, t.Result as HTTPNotificationEndpoint))
                 .Unwrap();
@@ -484,7 +483,7 @@ public async Task<List<Label>> GetLabelsAsync(string endpointId)
         {
             Arguments.CheckNonEmptyString(endpointId, nameof(endpointId));
 
-            return await _service.GetNotificationEndpointsIDLabelsAsync(endpointId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetNotificationEndpointsIDLabelsAsync(endpointId)).Labels;
         }
 
         /// <summary>
@@ -514,8 +513,7 @@ public async Task<Label> AddLabelAsync(string labelId, string endpointId)
 
             var mapping = new LabelMapping(labelId);
 
-            return await _service.PostNotificationEndpointIDLabelsAsync(endpointId, mapping)
-                .ContinueWith(t => t.Result.Label);
+            return (await _service.PostNotificationEndpointIDLabelsAsync(endpointId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/NotificationRulesApi.cs b/Client/NotificationRulesApi.cs
index aeb9837a0..70610ec42 100644
--- a/Client/NotificationRulesApi.cs
+++ b/Client/NotificationRulesApi.cs
@@ -234,8 +234,7 @@ public async Task<List<NotificationRule>> FindNotificationRulesAsync(string orgI
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await FindNotificationRulesAsync(orgId, new FindOptions())
-                .ContinueWith(t => t.Result._NotificationRules);
+            return (await FindNotificationRulesAsync(orgId, new FindOptions()))._NotificationRules;
         }
 
         /// <summary>
@@ -281,7 +280,7 @@ public async Task<List<Label>> GetLabelsAsync(string ruleId)
         {
             Arguments.CheckNonEmptyString(ruleId, nameof(ruleId));
 
-            return await _service.GetNotificationRulesIDLabelsAsync(ruleId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetNotificationRulesIDLabelsAsync(ruleId)).Labels;
         }
 
         /// <summary>
@@ -311,8 +310,7 @@ public async Task<Label> AddLabelAsync(string labelId, string ruleId)
 
             var mapping = new LabelMapping(labelId);
 
-            return await _service.PostNotificationRuleIDLabelsAsync(ruleId, mapping)
-                .ContinueWith(t => t.Result.Label);
+            return (await _service.PostNotificationRuleIDLabelsAsync(ruleId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/OrganizationsApi.cs b/Client/OrganizationsApi.cs
index b6cb52c1e..ba125eb17 100644
--- a/Client/OrganizationsApi.cs
+++ b/Client/OrganizationsApi.cs
@@ -91,7 +91,8 @@ public async Task<Organization> CloneOrganizationAsync(string clonedName, string
             Arguments.CheckNonEmptyString(clonedName, nameof(clonedName));
             Arguments.CheckNonEmptyString(bucketId, nameof(bucketId));
 
-            return await FindOrganizationByIdAsync(bucketId).ContinueWith(t => CloneOrganizationAsync(clonedName, t.Result)).Unwrap();
+            return await FindOrganizationByIdAsync(bucketId).ContinueWith(t => 
+                            CloneOrganizationAsync(clonedName, t.Result)).Unwrap();
         }
 
         /// <summary>
@@ -141,7 +142,7 @@ public async Task<Organization> FindOrganizationByIdAsync(string orgId)
         /// <returns>List all organizations</returns>
         public async Task<List<Organization>> FindOrganizationsAsync()
         {
-            return await _service.GetOrgsAsync().ContinueWith(t => t.Result.Orgs);
+            return (await _service.GetOrgsAsync()).Orgs;
         }
 
         /// <summary>
@@ -175,7 +176,7 @@ public async Task<List<string>> GetSecretsAsync(string orgId)
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await _service.GetOrgsIDSecretsAsync(orgId).ContinueWith(t => t.Result.Secrets);
+            return (await _service.GetOrgsIDSecretsAsync(orgId)).Secrets;
         }
 
         /// <summary>
@@ -269,7 +270,7 @@ public async Task<List<ResourceMember>> GetMembersAsync(string orgId)
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await _service.GetOrgsIDMembersAsync(orgId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetOrgsIDMembersAsync(orgId)).Users;
         }
 
         /// <summary>
@@ -349,7 +350,7 @@ public async Task<List<ResourceOwner>> GetOwnersAsync(string orgId)
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await _service.GetOrgsIDOwnersAsync(orgId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetOrgsIDOwnersAsync(orgId)).Users;
         }
 
         /// <summary>
@@ -429,7 +430,7 @@ public async Task<List<Label>> GetLabelsAsync(string orgId)
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await _service.GetOrgsIDLabelsAsync(orgId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetOrgsIDLabelsAsync(orgId)).Labels;
         }
 
         /// <summary>
@@ -459,7 +460,7 @@ public async Task<Label> AddLabelAsync(string labelId, string orgId)
 
             var mapping = new LabelMapping(labelId);
             
-            return await _service.PostOrgsIDLabelsAsync(orgId, mapping).ContinueWith(t => t.Result.Label);
+            return (await _service.PostOrgsIDLabelsAsync(orgId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/ScraperTargetsApi.cs b/Client/ScraperTargetsApi.cs
index 8ca9b6c85..6994121a5 100644
--- a/Client/ScraperTargetsApi.cs
+++ b/Client/ScraperTargetsApi.cs
@@ -169,7 +169,7 @@ public async Task<ScraperTargetResponse> FindScraperTargetByIdAsync(string scrap
         /// <returns>A list of ScraperTargets</returns>
         public async Task<List<ScraperTargetResponse>> FindScraperTargetsAsync()
         {
-            return await _service.GetScrapersAsync().ContinueWith(t => t.Result.Configurations);
+            return (await _service.GetScrapersAsync()).Configurations;
         }
 
         /// <summary>
@@ -193,8 +193,7 @@ public async Task<List<ScraperTargetResponse>> FindScraperTargetsByOrgIdAsync(st
         {
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await _service.GetScrapersAsync(null, orgId)
-                .ContinueWith(t => t.Result.Configurations);
+            return (await _service.GetScrapersAsync(null, orgId)).Configurations;
         }
 
         /// <summary>
@@ -218,7 +217,7 @@ public async Task<List<ResourceMember>> GetMembersAsync(string scraperTargetId)
         {
             Arguments.CheckNonEmptyString(scraperTargetId, nameof(scraperTargetId));
 
-            return await _service.GetScrapersIDMembersAsync(scraperTargetId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetScrapersIDMembersAsync(scraperTargetId)).Users;
         }
 
         /// <summary>
@@ -299,7 +298,7 @@ public async Task<List<ResourceOwner>> GetOwnersAsync(string scraperTargetId)
         {
             Arguments.CheckNonEmptyString(scraperTargetId, nameof(scraperTargetId));
 
-            return await _service.GetScrapersIDOwnersAsync(scraperTargetId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetScrapersIDOwnersAsync(scraperTargetId)).Users;
         }
 
         /// <summary>
@@ -381,7 +380,7 @@ public async Task<List<Label>> GetLabelsAsync(string scraperTargetId)
         {
             Arguments.CheckNonEmptyString(scraperTargetId, nameof(scraperTargetId));
 
-            return await _service.GetScrapersIDLabelsAsync(scraperTargetId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetScrapersIDLabelsAsync(scraperTargetId)).Labels;
         }
 
         /// <summary>
@@ -411,7 +410,7 @@ public async Task<Label> AddLabelAsync(string labelId, string scraperTargetId)
 
             var mapping = new LabelMapping(labelId);
 
-            return await _service.PostScrapersIDLabelsAsync(scraperTargetId, mapping).ContinueWith(t => t.Result.Label);
+            return (await _service.PostScrapersIDLabelsAsync(scraperTargetId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/SourcesApi.cs b/Client/SourcesApi.cs
index 4c30e2e7b..dc1b61aa7 100644
--- a/Client/SourcesApi.cs
+++ b/Client/SourcesApi.cs
@@ -131,7 +131,7 @@ public async Task<Source> FindSourceByIdAsync(string sourceId)
         /// <returns>A list of sources</returns>
         public async Task<List<Source>> FindSourcesAsync()
         {
-            return await _service.GetSourcesAsync().ContinueWith(t => t.Result._Sources);
+            return (await _service.GetSourcesAsync())._Sources;
         }
 
         /// <summary>
@@ -155,7 +155,7 @@ public async Task<List<Bucket>> FindBucketsBySourceIdAsync(string sourceId)
         {
             Arguments.CheckNonEmptyString(sourceId, nameof(sourceId));
 
-            return await _service.GetSourcesIDBucketsAsync(sourceId).ContinueWith(t => t.Result._Buckets);
+            return (await _service.GetSourcesIDBucketsAsync(sourceId))._Buckets;
         }
 
         /// <summary>
diff --git a/Client/TasksApi.cs b/Client/TasksApi.cs
index b2bd62d29..9f70f3a75 100644
--- a/Client/TasksApi.cs
+++ b/Client/TasksApi.cs
@@ -318,7 +318,7 @@ public async Task<List<TaskType>> FindTasksByOrganizationIdAsync(string orgId)
         /// <returns>A list of tasks</returns>
         public async Task<List<TaskType>> FindTasksAsync(string afterId = null, string userId = null, string orgId = null)
         {
-            return await _service.GetTasksAsync(null, null, afterId, userId, orgId).ContinueWith(t => t.Result._Tasks);
+            return (await _service.GetTasksAsync(null, null, afterId, userId, orgId))._Tasks;
         }
 
         /// <summary>
@@ -342,7 +342,7 @@ public async Task<List<ResourceMember>> GetMembersAsync(string taskId)
         {
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
 
-            return await _service.GetTasksIDMembersAsync(taskId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetTasksIDMembersAsync(taskId)).Users;
         }
 
         /// <summary>
@@ -422,7 +422,7 @@ public async Task<List<ResourceOwner>> GetOwnersAsync(string taskId)
         {
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
 
-            return await _service.GetTasksIDOwnersAsync(taskId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetTasksIDOwnersAsync(taskId)).Users;
         }
 
         /// <summary>
@@ -502,7 +502,7 @@ public async Task<List<LogEvent>> GetLogsAsync(string taskId)
         {
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
 
-            return await _service.GetTasksIDLogsAsync(taskId).ContinueWith(t => t.Result.Events);
+            return (await _service.GetTasksIDLogsAsync(taskId)).Events;
         }
 
         /// <summary>
@@ -563,8 +563,7 @@ public async Task<List<Run>> GetRunsAsync(string taskId, string orgId,
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
             Arguments.CheckNonEmptyString(orgId, nameof(orgId));
 
-            return await _service.GetTasksIDRunsAsync(taskId, null, null, limit, afterTime, beforeTime)
-                .ContinueWith(t => t.Result._Runs);
+            return (await _service.GetTasksIDRunsAsync(taskId, null, null, limit, afterTime, beforeTime))._Runs;
         }
 
         /// <summary>
@@ -649,12 +648,12 @@ public async Task<List<LogEvent>> GetRunLogsAsync(Run run)
         /// <param name="taskId">ID of task to get run logs for it</param>
         /// <param name="runId">ID of run to get logs for it</param>
         /// <returns>the list of all logs for a run</returns>
-        public Task<List<LogEvent>> GetRunLogsAsync(string taskId, string runId)
+        public async Task<List<LogEvent>> GetRunLogsAsync(string taskId, string runId)
         {
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
             Arguments.CheckNonEmptyString(runId, nameof(runId));
 
-            return _service.GetTasksIDRunsIDLogsAsync(taskId, runId).ContinueWith(t => t.Result.Events);
+            return (await _service.GetTasksIDRunsIDLogsAsync(taskId, runId)).Events;
         }
 
         /// <summary>
@@ -678,7 +677,7 @@ public async Task<List<Label>> GetLabelsAsync(string taskId)
         {
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
 
-            return await _service.GetTasksIDLabelsAsync(taskId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetTasksIDLabelsAsync(taskId)).Labels;
         }
 
         /// <summary>
@@ -701,14 +700,14 @@ public async Task<Label> AddLabelAsync(Label label, TaskType task)
         /// <param name="labelId">the ID of a label</param>
         /// <param name="taskId">the ID of a Task</param>
         /// <returns>added label</returns>
-        public Task<Label> AddLabelAsync(string labelId, string taskId)
+        public async Task<Label> AddLabelAsync(string labelId, string taskId)
         {
             Arguments.CheckNonEmptyString(taskId, nameof(taskId));
             Arguments.CheckNonEmptyString(labelId, nameof(labelId));
 
             var mapping = new LabelMapping(labelId);
 
-            return _service.PostTasksIDLabelsAsync(taskId, mapping).ContinueWith(t => t.Result.Label);
+            return (await _service.PostTasksIDLabelsAsync(taskId, mapping)).Label;
         }
 
         /// <summary>
diff --git a/Client/TelegrafsApi.cs b/Client/TelegrafsApi.cs
index 63c678702..403648aad 100644
--- a/Client/TelegrafsApi.cs
+++ b/Client/TelegrafsApi.cs
@@ -334,7 +334,7 @@ public async Task<List<Telegraf>> FindTelegrafsByOrgAsync(Organization organizat
         /// <returns>A list of telegraf configs</returns>
         public async Task<List<Telegraf>> FindTelegrafsByOrgIdAsync(string orgId)
         {
-            return await _service.GetTelegrafsAsync(orgId).ContinueWith(t => t.Result.Configurations);
+            return (await _service.GetTelegrafsAsync(orgId)).Configurations;
         }
 
         /// <summary>
@@ -382,7 +382,7 @@ public async Task<List<ResourceMember>> GetMembersAsync(string telegrafId)
         {
             Arguments.CheckNonEmptyString(telegrafId, nameof(telegrafId));
 
-            return await _service.GetTelegrafsIDMembersAsync(telegrafId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetTelegrafsIDMembersAsync(telegrafId)).Users;
         }
 
         /// <summary>
@@ -462,7 +462,7 @@ public async Task<List<ResourceOwner>> GetOwnersAsync(string telegrafId)
         {
             Arguments.CheckNonEmptyString(telegrafId, nameof(telegrafId));
 
-            return await _service.GetTelegrafsIDOwnersAsync(telegrafId).ContinueWith(t => t.Result.Users);
+            return (await _service.GetTelegrafsIDOwnersAsync(telegrafId)).Users;
         }
 
         /// <summary>
@@ -542,7 +542,7 @@ public async Task<List<Label>> GetLabelsAsync(string telegrafId)
         {
             Arguments.CheckNonEmptyString(telegrafId, nameof(telegrafId));
 
-            return await _service.GetTelegrafsIDLabelsAsync(telegrafId).ContinueWith(t => t.Result.Labels);
+            return (await _service.GetTelegrafsIDLabelsAsync(telegrafId)).Labels;
         }
 
         /// <summary>
@@ -570,8 +570,7 @@ public async Task<Label> AddLabelAsync(string labelId, string telegrafId)
             Arguments.CheckNonEmptyString(telegrafId, nameof(telegrafId));
             Arguments.CheckNonEmptyString(labelId, nameof(labelId));
 
-            return await _service.PostTelegrafsIDLabelsAsync(telegrafId, new LabelMapping(labelId))
-                .ContinueWith(t => t.Result.Label);
+            return (await _service.PostTelegrafsIDLabelsAsync(telegrafId, new LabelMapping(labelId))).Label;
         }
 
         /// <summary>
diff --git a/Client/UsersApi.cs b/Client/UsersApi.cs
index eb58abde4..9b1eb78a9 100644
--- a/Client/UsersApi.cs
+++ b/Client/UsersApi.cs
@@ -195,7 +195,7 @@ public async Task<User> FindUserByIdAsync(string userId)
         /// <returns>List all users</returns>
         public async Task<List<User>> FindUsersAsync()
         {
-            return await _service.GetUsersAsync().ContinueWith(t => t.Result._Users);
+            return (await _service.GetUsersAsync())._Users;
         }
 
         private async Task UpdateUserPasswordAsync(string userId, string userName, string oldPassword,