diff --git a/Dadata.Test/SuggestClientAsyncTest.cs b/Dadata.Test/SuggestClientAsyncTest.cs
index 8aa201b..edc504a 100644
--- a/Dadata.Test/SuggestClientAsyncTest.cs
+++ b/Dadata.Test/SuggestClientAsyncTest.cs
@@ -420,7 +420,7 @@ public async Task FindAffiliatedTest()
         }
 
         [Fact]
-        public async Task FindAffilliatedScopeTest()
+        public async Task FindAffiliatedScopeTest()
         {
             var request = new FindAffiliatedRequest("773006366201")
             {
diff --git a/Dadata.Test/SuggestClientSyncTest.cs b/Dadata.Test/SuggestClientSyncTest.cs
index d595516..92ae02e 100644
--- a/Dadata.Test/SuggestClientSyncTest.cs
+++ b/Dadata.Test/SuggestClientSyncTest.cs
@@ -299,7 +299,7 @@ public void FindAffiliatedTest()
         }
 
         [Fact]
-        public void FindAffilliatedScopeTest()
+        public void FindAffiliatedScopeTest()
         {
             var request = new FindAffiliatedRequest("773006366201")
             {
diff --git a/Dadata/CleanClientAsync.cs b/Dadata/CleanClientAsync.cs
index 780275c..1b69fd3 100644
--- a/Dadata/CleanClientAsync.cs
+++ b/Dadata/CleanClientAsync.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
@@ -13,7 +14,7 @@ public class CleanClientAsync : ClientBaseAsync, ICleanClientAsync
     {
         protected const string BASE_URL = "https://cleaner.dadata.ru/api/v1";
 
-        CustomCreationConverter<IDadataEntity> converter;
+        readonly CustomCreationConverter<IDadataEntity> converter;
 
         // maps concrete IDadataEntity types to corresponding structure types
         static Dictionary<Type, StructureType> TYPE_TO_STRUCTURE = new Dictionary<Type, StructureType>()
@@ -39,22 +40,23 @@ public CleanClientAsync(string token, string secret, string baseUrl = BASE_URL,
             serializer.Converters.Add(new StringEnumConverter());
         }
 
-        public async Task<T> Clean<T>(string source) where T : IDadataEntity
+        public async Task<T> Clean<T>(string source, CancellationToken cancellationToken = default) where T : IDadataEntity
         {
             // infer structure from target entity type
             var structure = new List<StructureType>(
                 new StructureType[] { TYPE_TO_STRUCTURE[typeof(T)] }
             );
-            // transform enity list to CleanRequest data structure
+            // transform entity list to CleanRequest data structure
             var data = new string[] { source };
-            var response = await Clean(structure, data);
+            var response = await Clean(structure, data, cancellationToken);
             return (T)response[0];
         }
 
-        public async Task<IList<IDadataEntity>> Clean(IEnumerable<StructureType> structure, IEnumerable<string> data)
+        public async Task<IList<IDadataEntity>> Clean(IEnumerable<StructureType> structure, IEnumerable<string> data,
+            CancellationToken cancellationToken = default)
         {
             var request = new CleanRequest(structure, data);
-            var response = await Execute<CleanResponse>(method: "clean", entity: null, request: request);
+            var response = await Execute<CleanResponse>(method: "clean", entity: null, request: request, cancellationToken);
             return response.data[0];
         }
 
diff --git a/Dadata/ClientBaseAsync.cs b/Dadata/ClientBaseAsync.cs
index fc09152..e60b64c 100644
--- a/Dadata/ClientBaseAsync.cs
+++ b/Dadata/ClientBaseAsync.cs
@@ -1,11 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
+using System.Collections.Specialized;
 using System.IO;
-using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using Dadata.Model;
@@ -14,7 +12,7 @@ namespace Dadata
 {
     public abstract class ClientBaseAsync : ClientBase
     {
-        protected HttpClient client;
+        protected readonly HttpClient client;
 
         public ClientBaseAsync(string token, string baseUrl, HttpClient client)
             : this(token, null, baseUrl, client) { }
@@ -25,32 +23,34 @@ public ClientBaseAsync(string token, string secret, string baseUrl, HttpClient c
             this.client = client ?? new HttpClient();
         }
 
-        protected async Task<T> ExecuteGet<T>(string method, string entity)
+        protected async Task<T> ExecuteGet<T>(string method, string entity, CancellationToken cancellationToken)
         {
             var parameters = new NameValueCollection();
-            return await ExecuteGet<T>(method, entity, parameters);
+            return await ExecuteGet<T>(method, entity, parameters, cancellationToken);
         }
 
-        protected async Task<T> ExecuteGet<T>(string method, string entity, NameValueCollection parameters)
+        protected async Task<T> ExecuteGet<T>(string method, string entity, NameValueCollection parameters,
+            CancellationToken cancellationToken)
         {
             var queryString = SerializeParameters(parameters);
             var url = BuildUrl(method: method, entity: entity, queryString: queryString);
             using (var httpRequest = CreateHttpRequest(verb: HttpMethod.Get, url: url))
-            using (var httpResponse = await client.SendAsync(httpRequest))
+            using (var httpResponse = await client.SendAsync(httpRequest, cancellationToken))
             {
                 httpResponse.EnsureSuccessStatusCode();
                 return await Deserialize<T>(httpResponse);
             }
         }
 
-        protected async Task<T> Execute<T>(string method, string entity, IDadataRequest request)
+        protected async Task<T> Execute<T>(string method, string entity, IDadataRequest request,
+            CancellationToken cancellationToken)
         {
             var url = BuildUrl(method: method, entity: entity);
             using (var httpRequest = CreateHttpRequest(verb: HttpMethod.Post, url: url))
             using (var httpContent = Serialize(httpRequest, request))
             {
                 httpRequest.Content = httpContent;
-                using (var httpResponse = await client.SendAsync(httpRequest))
+                using (var httpResponse = await client.SendAsync(httpRequest, cancellationToken))
                 {
                     httpResponse.EnsureSuccessStatusCode();
                     return await Deserialize<T>(httpResponse);
diff --git a/Dadata/ICleanClientAsync.cs b/Dadata/ICleanClientAsync.cs
index 757d353..6fca416 100644
--- a/Dadata/ICleanClientAsync.cs
+++ b/Dadata/ICleanClientAsync.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Dadata.Model;
 
@@ -6,7 +7,9 @@ namespace Dadata
 {
     public interface ICleanClientAsync
     {
-        Task<T> Clean<T>(string source) where T : IDadataEntity;
-        Task<IList<IDadataEntity>> Clean(IEnumerable<StructureType> structure, IEnumerable<string> data);
+        Task<T> Clean<T>(string source, CancellationToken cancellationToken = default) where T : IDadataEntity;
+
+        Task<IList<IDadataEntity>> Clean(IEnumerable<StructureType> structure, IEnumerable<string> data,
+            CancellationToken cancellationToken = default);
     }
 }
diff --git a/Dadata/IOutwardClientAsync.cs b/Dadata/IOutwardClientAsync.cs
index d1e4330..692ab7e 100644
--- a/Dadata/IOutwardClientAsync.cs
+++ b/Dadata/IOutwardClientAsync.cs
@@ -1,14 +1,22 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Dadata.Model;
 
 namespace Dadata
 {
     public interface IOutwardClientAsync
     {
-        Task<SuggestResponse<T>> Suggest<T>(string query, int count = 5) where T : IOutward;
-        Task<SuggestResponse<T>> Suggest<T>(SuggestOutwardRequest request) where T : IOutward;
-        Task<SuggestResponse<T>> Find<T>(string query) where T : IOutward;
-        Task<SuggestResponse<T>> Geolocate<T>(double lat, double lon, int radius_meters = 100, int count = 5)
+        Task<SuggestResponse<T>> Suggest<T>(string query, int count = 5, CancellationToken cancellationToken = default)
+            where T : IOutward;
+
+        Task<SuggestResponse<T>> Suggest<T>(SuggestOutwardRequest request,
+            CancellationToken cancellationToken = default) where T : IOutward;
+
+        Task<SuggestResponse<T>> Find<T>(string query, CancellationToken cancellationToken = default)
+            where T : IOutward;
+
+        Task<SuggestResponse<T>> Geolocate<T>(double lat, double lon, int radius_meters = 100, int count = 5,
+            CancellationToken cancellationToken = default)
             where T : IOutward;
     }
 }
diff --git a/Dadata/IProfileClientAsync.cs b/Dadata/IProfileClientAsync.cs
index 1eb7d93..0f2adb1 100644
--- a/Dadata/IProfileClientAsync.cs
+++ b/Dadata/IProfileClientAsync.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Dadata.Model;
 
@@ -6,9 +7,9 @@ namespace Dadata
 {
     public interface IProfileClientAsync
     {
-        Task<GetBalanceResponse> GetBalance();
-        Task<GetDailyStatsResponse> GetDailyStats();
-        Task<GetDailyStatsResponse> GetDailyStats(DateTime date);
-        Task<GetVersionsResponse> GetVersions();
+        Task<GetBalanceResponse> GetBalance(CancellationToken cancellationToken = default);
+        Task<GetDailyStatsResponse> GetDailyStats(CancellationToken cancellationToken = default);
+        Task<GetDailyStatsResponse> GetDailyStats(DateTime date, CancellationToken cancellationToken = default);
+        Task<GetVersionsResponse> GetVersions(CancellationToken cancellationToken = default);
     }
 }
diff --git a/Dadata/ISuggestClientAsync.cs b/Dadata/ISuggestClientAsync.cs
index 2b069dd..4e16e46 100644
--- a/Dadata/ISuggestClientAsync.cs
+++ b/Dadata/ISuggestClientAsync.cs
@@ -1,34 +1,35 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Dadata.Model;
 
 namespace Dadata
 {
     public interface ISuggestClientAsync
     {
-        Task<SuggestResponse<Address>> SuggestAddress(string query, int count = 5);
-        Task<SuggestResponse<Address>> SuggestAddress(SuggestAddressRequest request);
-        Task<SuggestResponse<Address>> FindAddress(string query);
-        Task<SuggestResponse<Address>> FindAddress(FindAddressRequest request);
-        Task<SuggestResponse<Address>> Geolocate(double lat, double lon, int radius_meters = 100, int count = 5);
-        Task<SuggestResponse<Address>> Geolocate(GeolocateRequest request);
-        Task<IplocateResponse> Iplocate(string ip, string language = "ru");
-        Task<SuggestResponse<Bank>> SuggestBank(string query, int count = 5);
-        Task<SuggestResponse<Bank>> SuggestBank(SuggestBankRequest request);
-        Task<SuggestResponse<Bank>> FindBank(string query);
-        Task<SuggestResponse<Bank>> FindBank(FindBankRequest request);
-        Task<SuggestResponse<Email>> SuggestEmail(string query, int count = 5);
-        Task<SuggestResponse<Email>> SuggestEmail(SuggestRequest request);
-        Task<SuggestResponse<FiasAddress>> SuggestFias(string query, int count = 5);
-        Task<SuggestResponse<FiasAddress>> SuggestFias(SuggestAddressRequest request);
-        Task<SuggestResponse<FiasAddress>> FindFias(string query);
-        Task<SuggestResponse<FiasAddress>> FindFias(SuggestRequest request);
-        Task<SuggestResponse<Fullname>> SuggestName(string query, int count = 5);
-        Task<SuggestResponse<Fullname>> SuggestName(SuggestNameRequest request);
-        Task<SuggestResponse<Party>> SuggestParty(string query, int count = 5);
-        Task<SuggestResponse<Party>> SuggestParty(SuggestPartyRequest request);
-        Task<SuggestResponse<Party>> FindParty(string query);
-        Task<SuggestResponse<Party>> FindParty(FindPartyRequest request);
-        Task<SuggestResponse<Party>> FindAffiliated(string query);
-        Task<SuggestResponse<Party>> FindAffiliated(FindAffiliatedRequest request);
+        Task<SuggestResponse<Address>> SuggestAddress(string query, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Address>> SuggestAddress(SuggestAddressRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Address>> FindAddress(string query, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Address>> FindAddress(FindAddressRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Address>> Geolocate(double lat, double lon, int radius_meters = 100, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Address>> Geolocate(GeolocateRequest request, CancellationToken cancellationToken = default);
+        Task<IplocateResponse> Iplocate(string ip, string language = "ru", CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Bank>> SuggestBank(string query, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Bank>> SuggestBank(SuggestBankRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Bank>> FindBank(string query, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Bank>> FindBank(FindBankRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Email>> SuggestEmail(string query, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Email>> SuggestEmail(SuggestRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<FiasAddress>> SuggestFias(string query, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<FiasAddress>> SuggestFias(SuggestAddressRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<FiasAddress>> FindFias(string query, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<FiasAddress>> FindFias(SuggestRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Fullname>> SuggestName(string query, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Fullname>> SuggestName(SuggestNameRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Party>> SuggestParty(string query, int count = 5, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Party>> SuggestParty(SuggestPartyRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Party>> FindParty(string query, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Party>> FindParty(FindPartyRequest request, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Party>> FindAffiliated(string query, CancellationToken cancellationToken = default);
+        Task<SuggestResponse<Party>> FindAffiliated(FindAffiliatedRequest request, CancellationToken cancellationToken = default);
     }
 }
diff --git a/Dadata/OutwardClientAsync.cs b/Dadata/OutwardClientAsync.cs
index 8ddeff8..3d74fd9 100644
--- a/Dadata/OutwardClientAsync.cs
+++ b/Dadata/OutwardClientAsync.cs
@@ -1,4 +1,5 @@
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using Dadata.Model;
 
@@ -11,30 +12,36 @@ public class OutwardClientAsync : ClientBaseAsync, IOutwardClientAsync
         public OutwardClientAsync(string token, string baseUrl = BASE_URL, HttpClient client = null)
             : base(token, baseUrl, client) { }
 
-        public async Task<SuggestResponse<T>> Suggest<T>(string query, int count = 5) where T : IOutward
+        public async Task<SuggestResponse<T>> Suggest<T>(string query, int count = 5, CancellationToken cancellationToken = default) where T : IOutward
         {
             var request = new SuggestOutwardRequest(query, count);
-            return await Suggest<T>(request);
+            return await Suggest<T>(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<T>> Suggest<T>(SuggestOutwardRequest request) where T : IOutward
+        public async Task<SuggestResponse<T>> Suggest<T>(SuggestOutwardRequest request,
+            CancellationToken cancellationToken = default) where T : IOutward
         {
             var entity = Outwards.GetEntityName(typeof(T));
-            return await Execute<SuggestResponse<T>>(method: SuggestionsMethod.Suggest, entity: entity, request: request);
+            return await Execute<SuggestResponse<T>>(method: SuggestionsMethod.Suggest, entity: entity,
+                request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<T>> Find<T>(string query) where T : IOutward
+        public async Task<SuggestResponse<T>> Find<T>(string query, CancellationToken cancellationToken = default)
+            where T : IOutward
         {
             var request = new SuggestOutwardRequest(query);
             var entity = Outwards.GetEntityName(typeof(T));
-            return await Execute<SuggestResponse<T>>(method: SuggestionsMethod.Find, entity: entity, request: request);
+            return await Execute<SuggestResponse<T>>(method: SuggestionsMethod.Find, entity: entity, request: request,
+                cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<T>> Geolocate<T>(double lat, double lon, int radius_meters = 100, int count = 5) where T : IOutward
+        public async Task<SuggestResponse<T>> Geolocate<T>(double lat, double lon, int radius_meters = 100,
+            int count = 5, CancellationToken cancellationToken = default) where T : IOutward
         {
             var request = new GeolocateRequest(lat, lon, radius_meters, count);
             var entity = Outwards.GetEntityName(typeof(T));
-            return await Execute<SuggestResponse<T>>(method: SuggestionsMethod.Geolocate, entity: entity, request: request);
+            return await Execute<SuggestResponse<T>>(method: SuggestionsMethod.Geolocate, entity: entity,
+                request: request, cancellationToken: cancellationToken);
         }
     }
 }
diff --git a/Dadata/ProfileClientAsync.cs b/Dadata/ProfileClientAsync.cs
index 0298e9c..7c7090a 100644
--- a/Dadata/ProfileClientAsync.cs
+++ b/Dadata/ProfileClientAsync.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Specialized;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using Dadata.Model;
 
@@ -14,27 +15,27 @@ public ProfileClientAsync(string token, string secret, string baseUrl = BASE_URL
             : base(token, secret, baseUrl, client) { }
 
 
-        public async Task<GetBalanceResponse> GetBalance()
+        public async Task<GetBalanceResponse> GetBalance(CancellationToken cancellationToken = default)
         {
-            return await ExecuteGet<GetBalanceResponse>(method: "profile", entity: "balance");
+            return await ExecuteGet<GetBalanceResponse>(method: "profile", entity: "balance", cancellationToken);
         }
 
-        public async Task<GetDailyStatsResponse> GetDailyStats()
+        public async Task<GetDailyStatsResponse> GetDailyStats(CancellationToken cancellationToken = default)
         {
-            return await GetDailyStats(DateTime.Today);
+            return await GetDailyStats(DateTime.Today, cancellationToken);
         }
 
-        public async Task<GetDailyStatsResponse> GetDailyStats(DateTime date)
+        public async Task<GetDailyStatsResponse> GetDailyStats(DateTime date, CancellationToken cancellationToken)
         {
             var parameters = new NameValueCollection(1);
             parameters.Add("date", date.ToString("yyyy-MM-dd"));
-            return await ExecuteGet<GetDailyStatsResponse>(method: "stat", entity: "daily", parameters: parameters);
+            return await ExecuteGet<GetDailyStatsResponse>(method: "stat", entity: "daily", parameters: parameters,
+                cancellationToken);
         }
 
-        public async Task<GetVersionsResponse> GetVersions()
+        public async Task<GetVersionsResponse> GetVersions(CancellationToken cancellationToken = default)
         {
-            return await ExecuteGet<GetVersionsResponse>(method: "version", entity: null);
+            return await ExecuteGet<GetVersionsResponse>(method: "version", entity: null, cancellationToken);
         }
-
     }
 }
diff --git a/Dadata/SuggestClientAsync.cs b/Dadata/SuggestClientAsync.cs
index 9263967..02ee5a7 100644
--- a/Dadata/SuggestClientAsync.cs
+++ b/Dadata/SuggestClientAsync.cs
@@ -1,5 +1,6 @@
 using System.Collections.Specialized;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using Dadata.Model;
 
@@ -14,164 +15,203 @@ public SuggestClientAsync(string token, string baseUrl = BASE_URL, HttpClient cl
 
         #region Address
 
-        public async Task<SuggestResponse<Address>> SuggestAddress(string query, int count = 5)
+        public async Task<SuggestResponse<Address>> SuggestAddress(string query, int count = 5,
+            CancellationToken cancellationToken = default)
         {
             var request = new SuggestAddressRequest(query, count);
             return await SuggestAddress(request);
         }
 
-        public async Task<SuggestResponse<Address>> SuggestAddress(SuggestAddressRequest request)
+        public async Task<SuggestResponse<Address>> SuggestAddress(SuggestAddressRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Address>>(method: SuggestionsMethod.Suggest, entity: SuggestionsEntity.Address, request: request);
+            return await Execute<SuggestResponse<Address>>(method: SuggestionsMethod.Suggest,
+                entity: SuggestionsEntity.Address, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<Address>> FindAddress(string query)
+        public async Task<SuggestResponse<Address>> FindAddress(string query,
+            CancellationToken cancellationToken = default)
         {
             var request = new FindAddressRequest(query);
-            return await FindAddress(request);
+            return await FindAddress(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Address>> FindAddress(FindAddressRequest request)
+        public async Task<SuggestResponse<Address>> FindAddress(FindAddressRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Address>>(method: SuggestionsMethod.Find, entity: SuggestionsEntity.Address, request: request);
+            return await Execute<SuggestResponse<Address>>(method: SuggestionsMethod.Find,
+                entity: SuggestionsEntity.Address, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<Address>> Geolocate(double lat, double lon, int radius_meters = 100, int count = 5)
+        public async Task<SuggestResponse<Address>> Geolocate(double lat, double lon, int radius_meters = 100,
+            int count = 5, CancellationToken cancellationToken = default)
         {
             var request = new GeolocateRequest(lat, lon, radius_meters, count);
-            return await Geolocate(request);
+            return await Geolocate(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Address>> Geolocate(GeolocateRequest request)
+        public async Task<SuggestResponse<Address>> Geolocate(GeolocateRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Address>>(method: SuggestionsMethod.Geolocate, entity: SuggestionsEntity.Address, request: request);
+            return await Execute<SuggestResponse<Address>>(method: SuggestionsMethod.Geolocate,
+                entity: SuggestionsEntity.Address, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<IplocateResponse> Iplocate(string ip, string language = "ru")
+        public async Task<IplocateResponse> Iplocate(string ip, string language = "ru",
+            CancellationToken cancellationToken = default)
         {
-            var parameters = new NameValueCollection();
-            parameters.Add("ip", ip);
-            parameters.Add("language", language);
-            return await ExecuteGet<IplocateResponse>(method: SuggestionsMethod.Iplocate, entity: SuggestionsEntity.Address, parameters: parameters);
+            var parameters = new NameValueCollection
+            {
+                { "ip", ip },
+                { "language", language }
+            };
+            return await ExecuteGet<IplocateResponse>(
+                method: SuggestionsMethod.Iplocate,
+                entity: SuggestionsEntity.Address,
+                parameters: parameters,
+                cancellationToken: cancellationToken);
         }
 
         #endregion
 
         #region Bank
 
-        public async Task<SuggestResponse<Bank>> SuggestBank(string query, int count = 5)
+        public async Task<SuggestResponse<Bank>> SuggestBank(string query, int count = 5, CancellationToken cancellationToken = default)
         {
             var request = new SuggestBankRequest(query, count);
-            return await SuggestBank(request);
+            return await SuggestBank(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Bank>> SuggestBank(SuggestBankRequest request)
+        public async Task<SuggestResponse<Bank>> SuggestBank(SuggestBankRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Bank>>(method: SuggestionsMethod.Suggest, entity: SuggestionsEntity.Bank, request: request);
+            return await Execute<SuggestResponse<Bank>>(method: SuggestionsMethod.Suggest,
+                entity: SuggestionsEntity.Bank, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<Bank>> FindBank(string query)
+        public async Task<SuggestResponse<Bank>> FindBank(string query, CancellationToken cancellationToken = default)
         {
             var request = new FindBankRequest(query);
-            return await FindBank(request);
+            return await FindBank(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Bank>> FindBank(FindBankRequest request)
+        public async Task<SuggestResponse<Bank>> FindBank(FindBankRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Bank>>(method: SuggestionsMethod.Find, entity: SuggestionsEntity.Bank, request: request);
+            return await Execute<SuggestResponse<Bank>>(method: SuggestionsMethod.Find, entity: SuggestionsEntity.Bank,
+                request: request, cancellationToken: cancellationToken);
         }
 
         #endregion
 
         #region Email
 
-        public async Task<SuggestResponse<Email>> SuggestEmail(string query, int count = 5)
+        public async Task<SuggestResponse<Email>> SuggestEmail(string query, int count = 5,
+            CancellationToken cancellationToken = default)
         {
             var request = new SuggestRequest(query, count);
-            return await SuggestEmail(request);
+            return await SuggestEmail(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Email>> SuggestEmail(SuggestRequest request)
+        public async Task<SuggestResponse<Email>> SuggestEmail(SuggestRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Email>>(method: SuggestionsMethod.Suggest, entity: SuggestionsEntity.Email, request: request);
+            return await Execute<SuggestResponse<Email>>(method: SuggestionsMethod.Suggest,
+                entity: SuggestionsEntity.Email, request: request, cancellationToken: cancellationToken);
         }
 
         #endregion
 
         #region Fias
 
-        public async Task<SuggestResponse<FiasAddress>> SuggestFias(string query, int count = 5)
+        public async Task<SuggestResponse<FiasAddress>> SuggestFias(string query, int count = 5,
+            CancellationToken cancellationToken = default)
         {
             var request = new SuggestAddressRequest(query, count);
-            return await SuggestFias(request);
+            return await SuggestFias(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<FiasAddress>> SuggestFias(SuggestAddressRequest request)
+        public async Task<SuggestResponse<FiasAddress>> SuggestFias(SuggestAddressRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<FiasAddress>>(method: SuggestionsMethod.Suggest, entity: SuggestionsEntity.Fias, request: request);
+            return await Execute<SuggestResponse<FiasAddress>>(method: SuggestionsMethod.Suggest,
+                entity: SuggestionsEntity.Fias, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<FiasAddress>> FindFias(string query)
+        public async Task<SuggestResponse<FiasAddress>> FindFias(string query, CancellationToken cancellationToken = default)
         {
             var request = new SuggestRequest(query);
-            return await FindFias(request);
+            return await FindFias(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<FiasAddress>> FindFias(SuggestRequest request)
+        public async Task<SuggestResponse<FiasAddress>> FindFias(SuggestRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<FiasAddress>>(method: SuggestionsMethod.Find, entity: SuggestionsEntity.Fias, request: request);
+            return await Execute<SuggestResponse<FiasAddress>>(method: SuggestionsMethod.Find,
+                entity: SuggestionsEntity.Fias, request: request, cancellationToken: cancellationToken);
         }
 
         #endregion
 
         #region Name
 
-        public async Task<SuggestResponse<Fullname>> SuggestName(string query, int count = 5)
+        public async Task<SuggestResponse<Fullname>> SuggestName(string query, int count = 5,
+            CancellationToken cancellationToken = default)
         {
             var request = new SuggestNameRequest(query, count);
-            return await SuggestName(request);
+            return await SuggestName(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Fullname>> SuggestName(SuggestNameRequest request)
+        public async Task<SuggestResponse<Fullname>> SuggestName(SuggestNameRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Fullname>>(method: SuggestionsMethod.Suggest, entity: SuggestionsEntity.Name, request: request);
+            return await Execute<SuggestResponse<Fullname>>(method: SuggestionsMethod.Suggest,
+                entity: SuggestionsEntity.Name, request: request, cancellationToken: cancellationToken);
         }
 
         #endregion
 
         #region Party
 
-        public async Task<SuggestResponse<Party>> SuggestParty(string query, int count = 5)
+        public async Task<SuggestResponse<Party>> SuggestParty(string query, int count = 5,
+            CancellationToken cancellationToken = default)
         {
             var request = new SuggestPartyRequest(query, count);
-            return await SuggestParty(request);
+            return await SuggestParty(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Party>> SuggestParty(SuggestPartyRequest request)
+        public async Task<SuggestResponse<Party>> SuggestParty(SuggestPartyRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Party>>(method: SuggestionsMethod.Suggest, entity: SuggestionsEntity.Party, request: request);
+            return await Execute<SuggestResponse<Party>>(method: SuggestionsMethod.Suggest,
+                entity: SuggestionsEntity.Party, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<Party>> FindParty(string query)
+        public async Task<SuggestResponse<Party>> FindParty(string query, CancellationToken cancellationToken = default)
         {
             var request = new FindPartyRequest(query);
-            return await FindParty(request);
+            return await FindParty(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Party>> FindParty(FindPartyRequest request)
+        public async Task<SuggestResponse<Party>> FindParty(FindPartyRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Party>>(method: SuggestionsMethod.Find, entity: SuggestionsEntity.Party, request: request);
+            return await Execute<SuggestResponse<Party>>(method: SuggestionsMethod.Find,
+                entity: SuggestionsEntity.Party, request: request, cancellationToken: cancellationToken);
         }
 
-        public async Task<SuggestResponse<Party>> FindAffiliated(string query)
+        public async Task<SuggestResponse<Party>> FindAffiliated(string query,
+            CancellationToken cancellationToken = default)
         {
             var request = new FindAffiliatedRequest(query);
-            return await FindAffiliated(request);
+            return await FindAffiliated(request, cancellationToken);
         }
 
-        public async Task<SuggestResponse<Party>> FindAffiliated(FindAffiliatedRequest request)
+        public async Task<SuggestResponse<Party>> FindAffiliated(FindAffiliatedRequest request,
+            CancellationToken cancellationToken = default)
         {
-            return await Execute<SuggestResponse<Party>>(method: SuggestionsMethod.FindAffiliated, entity: SuggestionsEntity.Party, request: request);
+            return await Execute<SuggestResponse<Party>>(method: SuggestionsMethod.FindAffiliated,
+                entity: SuggestionsEntity.Party, request: request, cancellationToken: cancellationToken);
         }
 
         #endregion