diff --git a/src/Clients/ChannelClient.Crud.cs b/src/Clients/ChannelClient.Crud.cs
index 870444b9..7a7b2e48 100644
--- a/src/Clients/ChannelClient.Crud.cs
+++ b/src/Clients/ChannelClient.Crud.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Models;
 using StreamChat.Rest;
@@ -22,82 +23,106 @@ public async Task<ChannelGetResponse> GetOrCreateAsync(string channelType, strin
                     },
                 });
 
+        public async Task<ChannelGetResponse> GetOrCreateAsync(string channelType, string channelId, string createdBy,
+            string[] members, CancellationToken cancellationToken = default)
+            => await GetOrCreateAsync(channelType,
+                channelId,
+                new ChannelGetRequest
+                {
+                    Data = new ChannelRequest
+                    {
+                        CreatedBy = new UserRequest { Id = createdBy },
+                        Members = members.Select(x => new ChannelMember { UserId = x }),
+                    },
+                },
+                cancellationToken: cancellationToken);
+
         public async Task<ChannelGetResponse> GetOrCreateAsync(string channelType, string channelId,
-            ChannelGetRequest channelRequest)
+            ChannelGetRequest channelRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ChannelGetResponse>($"channels/{channelType}/{channelId}/query",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                channelRequest);
+                channelRequest,
+                cancellationToken: cancellationToken);
 
-        public async Task<ChannelGetResponse> GetOrCreateAsync(string channelType, ChannelGetRequest channelRequest)
+        public async Task<ChannelGetResponse> GetOrCreateAsync(string channelType, ChannelGetRequest channelRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ChannelGetResponse>($"channels/{channelType}/query",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                channelRequest);
+                channelRequest,
+                cancellationToken: cancellationToken);
 
         public async Task<UpdateChannelResponse> UpdateAsync(string channelType, string channelId,
-            ChannelUpdateRequest updateRequest)
+            ChannelUpdateRequest updateRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<UpdateChannelResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                updateRequest);
+                updateRequest,
+                cancellationToken: cancellationToken);
 
         public async Task<PartialUpdateChannelResponse> PartialUpdateAsync(string channelType, string channelId,
-            PartialUpdateChannelRequest partialUpdateChannelRequest)
+            PartialUpdateChannelRequest partialUpdateChannelRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<PartialUpdateChannelResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.PATCH,
                 HttpStatusCode.OK,
-                partialUpdateChannelRequest);
+                partialUpdateChannelRequest,
+                cancellationToken: cancellationToken);
 
-        public async Task<ApiResponse> DeleteAsync(string channelType, string channelId)
+        public async Task<ApiResponse> DeleteAsync(string channelType, string channelId, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.DELETE,
-                HttpStatusCode.OK);
+                HttpStatusCode.OK,
+                cancellationToken: cancellationToken);
 
-        public async Task<TruncateResponse> TruncateAsync(string channelType, string channelId)
-            => await TruncateAsync(channelType, channelId, null);
+        public async Task<TruncateResponse> TruncateAsync(string channelType, string channelId, CancellationToken cancellationToken = default)
+            => await TruncateAsync(channelType, channelId, null, cancellationToken);
 
         public async Task<TruncateResponse> TruncateAsync(string channelType, string channelId,
-            TruncateOptions truncateOptions)
+            TruncateOptions truncateOptions, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<TruncateResponse>($"channels/{channelType}/{channelId}/truncate",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                truncateOptions);
+                truncateOptions,
+                cancellationToken: cancellationToken);
 
-        public Task<ChannelMemberResponse> PinAsync(string channelType, string channelId, string userId)
+        public Task<ChannelMemberResponse> PinAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => UpdateMemberPartialAsync(channelType, channelId, new ChannelMemberPartialRequest
             {
-                UserId = userId, Set = new Dictionary<string, object>()
+                UserId = userId,
+                Set = new Dictionary<string, object>()
                 {
                     { "pinned", true },
                 },
-            });
+            }, cancellationToken);
 
-        public Task<ChannelMemberResponse> UnpinAsync(string channelType, string channelId, string userId)
+        public Task<ChannelMemberResponse> UnpinAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => UpdateMemberPartialAsync(channelType, channelId, new ChannelMemberPartialRequest
             {
-                UserId = userId, Set = new Dictionary<string, object>()
+                UserId = userId,
+                Set = new Dictionary<string, object>()
                 {
                     { "pinned", false },
                 },
-            });
+            }, cancellationToken);
 
-        public Task<ChannelMemberResponse> ArchiveAsync(string channelType, string channelId, string userId)
+        public Task<ChannelMemberResponse> ArchiveAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => UpdateMemberPartialAsync(channelType, channelId, new ChannelMemberPartialRequest
             {
-                UserId = userId, Set = new Dictionary<string, object>()
+                UserId = userId,
+                Set = new Dictionary<string, object>()
                 {
                     { "archived", true },
                 },
-            });
+            }, cancellationToken);
 
-        public Task<ChannelMemberResponse> UnarchiveAsync(string channelType, string channelId, string userId)
+        public Task<ChannelMemberResponse> UnarchiveAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => UpdateMemberPartialAsync(channelType, channelId, new ChannelMemberPartialRequest
             {
-                UserId = userId, Set = new Dictionary<string, object>()
+                UserId = userId,
+                Set = new Dictionary<string, object>()
                 {
                     { "archived", false },
                 },
-            });
+            }, cancellationToken);
     }
 }
\ No newline at end of file
diff --git a/src/Clients/ChannelClient.FilterTags.cs b/src/Clients/ChannelClient.FilterTags.cs
index ce1a5fc3..6a083a78 100644
--- a/src/Clients/ChannelClient.FilterTags.cs
+++ b/src/Clients/ChannelClient.FilterTags.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Models;
 using StreamChat.Rest;
@@ -21,7 +22,7 @@ public Task<UpdateChannelResponse> AddFilterTagsAsync(string channelType, string
         /// Adds filter tags to the channel.
         /// </summary>
         public async Task<UpdateChannelResponse> AddFilterTagsAsync(string channelType, string channelId,
-            IEnumerable<string> filterTags, MessageRequest msg = null) => await ExecuteRequestAsync<UpdateChannelResponse>(
+            IEnumerable<string> filterTags, MessageRequest msg = null, CancellationToken cancellationToken = default) => await ExecuteRequestAsync<UpdateChannelResponse>(
             $"channels/{channelType}/{channelId}",
             HttpMethod.POST,
             HttpStatusCode.Created,
@@ -41,7 +42,8 @@ public Task<ApiResponse> RemoveFilterTagsAsync(string channelType, string channe
         /// Removes filter tags from the channel.
         /// </summary>
         public async Task<ApiResponse> RemoveFilterTagsAsync(string channelType, string channelId,
-            IEnumerable<string> filterTags, MessageRequest msg = null) => await ExecuteRequestAsync<ApiResponse>(
+            IEnumerable<string> filterTags, MessageRequest msg = null,
+            CancellationToken cancellationToken = default) => await ExecuteRequestAsync<ApiResponse>(
             $"channels/{channelType}/{channelId}",
             HttpMethod.POST,
             HttpStatusCode.Created,
@@ -49,6 +51,7 @@ public async Task<ApiResponse> RemoveFilterTagsAsync(string channelType, string
             {
                 RemoveFilterTags = filterTags,
                 Message = msg,
-            });
+            },
+            cancellationToken: cancellationToken);
     }
 }
diff --git a/src/Clients/ChannelClient.Members.cs b/src/Clients/ChannelClient.Members.cs
index 2e60c0c2..abc9f341 100644
--- a/src/Clients/ChannelClient.Members.cs
+++ b/src/Clients/ChannelClient.Members.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Models;
 using StreamChat.Rest;
@@ -11,7 +12,10 @@ public partial class ChannelClient
         public async Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, params string[] userIds)
             => await AddMembersAsync(channelType, channelId, userIds, null, null);
 
-        public async Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, IEnumerable<string> userIds, MessageRequest msg, AddMemberOptions options)
+        public async Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, string[] userIds, CancellationToken cancellationToken = default)
+            => await AddMembersAsync(channelType, channelId, userIds, null, null, cancellationToken);
+
+        public async Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, IEnumerable<string> userIds, MessageRequest msg, AddMemberOptions options, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<UpdateChannelResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
@@ -21,9 +25,10 @@ public async Task<UpdateChannelResponse> AddMembersAsync(string channelType, str
                     HideHistory = options?.HideHistory,
                     HideHistoryBefore = options?.HideHistoryBefore,
                     Message = msg,
-                });
+                },
+                cancellationToken: cancellationToken);
 
-        public async Task<ApiResponse> RemoveMembersAsync(string channelType, string channelId, IEnumerable<string> userIds, MessageRequest msg = null)
+        public async Task<ApiResponse> RemoveMembersAsync(string channelType, string channelId, IEnumerable<string> userIds, MessageRequest msg = null, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
@@ -31,51 +36,55 @@ public async Task<ApiResponse> RemoveMembersAsync(string channelType, string cha
                 {
                     RemoveMembers = userIds,
                     Message = msg,
-                });
+                },
+                cancellationToken: cancellationToken);
 
-        public async Task<ChannelMemberResponse> UpdateMemberPartialAsync(string channelType, string channelId, ChannelMemberPartialRequest channelMemberPartialRequest)
+        public async Task<ChannelMemberResponse> UpdateMemberPartialAsync(string channelType, string channelId, ChannelMemberPartialRequest channelMemberPartialRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ChannelMemberResponse>($"channels/{channelType}/{channelId}/member/{channelMemberPartialRequest.UserId}",
                 HttpMethod.PATCH,
                 HttpStatusCode.OK,
-                channelMemberPartialRequest);
+                channelMemberPartialRequest,
+                cancellationToken: cancellationToken);
 
-        public async Task<QueryMembersResponse> QueryMembersAsync(QueryMembersRequest queryMembersRequest)
+        public async Task<QueryMembersResponse> QueryMembersAsync(QueryMembersRequest queryMembersRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<QueryMembersResponse>("members",
                 HttpMethod.GET,
                 HttpStatusCode.OK,
-                queryParams: queryMembersRequest.ToQueryParameters());
+                queryParams: queryMembersRequest.ToQueryParameters(),
+                cancellationToken: cancellationToken);
 
-        public async Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelId, AssignRoleRequest roleRequest)
+        public async Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelId, AssignRoleRequest roleRequest, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<UpdateChannelResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                roleRequest);
+                roleRequest,
+                cancellationToken: cancellationToken);
 
-        public async Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, string userId, MessageRequest msg = null)
-            => await InviteAsync(channelType, channelId, new[] { userId }, msg);
+        public async Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, string userId, MessageRequest msg = null, CancellationToken cancellationToken = default)
+            => await InviteAsync(channelType, channelId, new[] { userId }, msg, cancellationToken);
 
-        public async Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds)
-            => await InviteAsync(channelType, channelId, userIds, null);
+        public async Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds, CancellationToken cancellationToken = default)
+            => await InviteAsync(channelType, channelId, userIds, null, cancellationToken);
 
-        public async Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds, MessageRequest msg = null)
+        public async Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds, MessageRequest msg = null, CancellationToken cancellationToken = default)
             => await UpdateAsync(channelType, channelId, new ChannelUpdateRequest
             {
                 Invites = userIds,
                 Message = msg,
-            });
+            }, cancellationToken);
 
-        public async Task<UpdateChannelResponse> AcceptInviteAsync(string channelType, string channelId, string userId)
+        public async Task<UpdateChannelResponse> AcceptInviteAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => await UpdateAsync(channelType, channelId, new ChannelUpdateRequest
             {
                 AcceptInvite = true,
                 UserId = userId,
-            });
+            }, cancellationToken);
 
-        public async Task<UpdateChannelResponse> RejectInviteAsync(string channelType, string channelId, string userId)
+        public async Task<UpdateChannelResponse> RejectInviteAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => await UpdateAsync(channelType, channelId, new ChannelUpdateRequest
             {
                 RejectInvite = true,
                 UserId = userId,
-            });
+            }, cancellationToken);
     }
 }
\ No newline at end of file
diff --git a/src/Clients/ChannelClient.Moderation.cs b/src/Clients/ChannelClient.Moderation.cs
index d4956abe..c681dbf8 100644
--- a/src/Clients/ChannelClient.Moderation.cs
+++ b/src/Clients/ChannelClient.Moderation.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Models;
 using StreamChat.Rest;
@@ -8,28 +9,32 @@ namespace StreamChat.Clients
 {
     public partial class ChannelClient
     {
-        public async Task<ApiResponse> AddModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds)
+        public async Task<ApiResponse> AddModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                new { add_moderators = userIds });
+                new { add_moderators = userIds },
+                cancellationToken: cancellationToken);
 
-        public async Task<ApiResponse> DemoteModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds)
+        public async Task<ApiResponse> DemoteModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                new { demote_moderators = userIds });
+                new { demote_moderators = userIds },
+                cancellationToken: cancellationToken);
 
-        public async Task<ChannelMuteResponse> MuteChannelAsync(ChannelMuteRequest request)
+        public async Task<ChannelMuteResponse> MuteChannelAsync(ChannelMuteRequest request, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ChannelMuteResponse>("moderation/mute/channel",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                request);
+                request,
+                cancellationToken: cancellationToken);
 
-        public async Task<ChannelUnmuteResponse> UnmuteChannelAsync(ChannelUnmuteRequest request)
+        public async Task<ChannelUnmuteResponse> UnmuteChannelAsync(ChannelUnmuteRequest request, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ChannelUnmuteResponse>("moderation/unmute/channel",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                request);
+                request,
+                cancellationToken: cancellationToken);
     }
 }
\ No newline at end of file
diff --git a/src/Clients/ChannelClient.cs b/src/Clients/ChannelClient.cs
index f7ec8869..63cb388e 100644
--- a/src/Clients/ChannelClient.cs
+++ b/src/Clients/ChannelClient.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Models;
 using StreamChat.Rest;
@@ -12,41 +13,48 @@ internal ChannelClient(IRestClient client) : base(client)
         {
         }
 
-        public async Task<QueryChannelResponse> QueryChannelsAsync(QueryChannelsOptions opts)
+        public async Task<QueryChannelResponse> QueryChannelsAsync(QueryChannelsOptions opts, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<QueryChannelResponse>("channels",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                opts);
+                opts,
+                cancellationToken: cancellationToken);
 
-        public async Task<AsyncOperationResponse> ExportChannelAsync(ExportChannelItem request)
-            => await ExportChannelsAsync(new ExportChannelRequest { Channels = new[] { request } });
+        public async Task<AsyncOperationResponse> ExportChannelAsync(ExportChannelItem request, CancellationToken cancellationToken = default)
+            => await ExportChannelsAsync(
+                new ExportChannelRequest { Channels = new[] { request } },
+                cancellationToken: cancellationToken);
 
-        public async Task<AsyncOperationResponse> ExportChannelsAsync(ExportChannelRequest request)
+        public async Task<AsyncOperationResponse> ExportChannelsAsync(ExportChannelRequest request, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<AsyncOperationResponse>("export_channels",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                request);
+                request,
+                cancellationToken: cancellationToken);
 
-        public async Task<ExportChannelsStatusResponse> GetExportChannelsStatusAsync(string taskId)
+        public async Task<ExportChannelsStatusResponse> GetExportChannelsStatusAsync(string taskId, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ExportChannelsStatusResponse>($"export_channels/{taskId}",
                 HttpMethod.GET,
-                HttpStatusCode.OK);
+                HttpStatusCode.OK,
+                cancellationToken: cancellationToken);
 
-        public async Task<AsyncOperationResponse> DeleteChannelsAsync(IEnumerable<string> cids, bool hardDelete = false)
+        public async Task<AsyncOperationResponse> DeleteChannelsAsync(IEnumerable<string> cids, bool hardDelete = false, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<AsyncOperationResponse>("channels/delete",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                new { cids = cids, hard_delete = hardDelete });
+                new { cids = cids, hard_delete = hardDelete },
+                cancellationToken: cancellationToken);
 
-        public async Task<AsyncOperationResponse> UpdateChannelsBatchAsync(ChannelsBatchOptions options)
+        public async Task<AsyncOperationResponse> UpdateChannelsBatchAsync(ChannelsBatchOptions options, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<AsyncOperationResponse>("channels/batch",
                 HttpMethod.PUT,
                 HttpStatusCode.Created,
-                options);
+                options,
+                cancellationToken: cancellationToken);
 
         public ChannelBatchUpdater BatchUpdater() => new ChannelBatchUpdater(this);
 
-        public async Task<ApiResponse> HideAsync(string channelType, string channelId, string userId, bool clearHistory = false)
+        public async Task<ApiResponse> HideAsync(string channelType, string channelId, string userId, bool clearHistory = false, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}/hide",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
@@ -54,12 +62,14 @@ public async Task<ApiResponse> HideAsync(string channelType, string channelId, s
                 {
                     user_id = userId,
                     clear_history = clearHistory,
-                });
+                },
+                cancellationToken: cancellationToken);
 
-        public async Task<ApiResponse> ShowAsync(string channelType, string channelId, string userId)
+        public async Task<ApiResponse> ShowAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default)
             => await ExecuteRequestAsync<ApiResponse>($"channels/{channelType}/{channelId}/show",
                 HttpMethod.POST,
                 HttpStatusCode.Created,
-                new { user_id = userId });
+                new { user_id = userId },
+                cancellationToken: cancellationToken);
     }
 }
diff --git a/src/Clients/ClientBase.cs b/src/Clients/ClientBase.cs
index d5970fb3..5640fd62 100644
--- a/src/Clients/ClientBase.cs
+++ b/src/Clients/ClientBase.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Exceptions;
 using StreamChat.Models;
@@ -26,11 +27,12 @@ protected async Task<T> ExecuteRequestAsync<T>(
             HttpStatusCode expectedStatusCode,
             object body = null,
             IEnumerable<KeyValuePair<string, string>> queryParams = null,
-            MultipartFormDataContent multipartBody = null) where T : ApiResponse
+            MultipartFormDataContent multipartBody = null,
+            CancellationToken cancellationToken = default) where T : ApiResponse
         {
             var req = _client.BuildRestRequest(relativeUri, method, body, queryParams, multipartBody);
 
-            var resp = await _client.ExecuteAsync(req);
+            var resp = await _client.ExecuteAsync(req, cancellationToken);
 
             if (resp.StatusCode == expectedStatusCode)
             {
diff --git a/src/Clients/IChannelClient.cs b/src/Clients/IChannelClient.cs
index f3c4e77f..e5d45231 100644
--- a/src/Clients/IChannelClient.cs
+++ b/src/Clients/IChannelClient.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using StreamChat.Models;
 
@@ -16,31 +17,37 @@ public interface IChannelClient
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_members/?language=csharp</remarks>
         Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, params string[] userIds);
 
+        /// <summary>
+        /// Adds members to a channel.
+        /// </summary>
+        /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_members/?language=csharp</remarks>
+        Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, string[] userIds, CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Adds members to a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_members/?language=csharp</remarks>
         Task<UpdateChannelResponse> AddMembersAsync(string channelType, string channelId, IEnumerable<string> userIds,
-            MessageRequest msg, AddMemberOptions options);
+            MessageRequest msg, AddMemberOptions options, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Makes a member a moderator in a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/moderation/?language=csharp</remarks>
-        Task<ApiResponse> AddModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds);
+        Task<ApiResponse> AddModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Assigns a role to a user.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/chat_permission_policies/?language=csharp</remarks>
         Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelId,
-            AssignRoleRequest roleRequest);
+            AssignRoleRequest roleRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Deletes a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_delete/?language=csharp</remarks>
-        Task<ApiResponse> DeleteAsync(string channelType, string channelId);
+        Task<ApiResponse> DeleteAsync(string channelType, string channelId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Deletes multiple channels.</para>
@@ -48,14 +55,14 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// You can use <see cref="ITaskClient.GetTaskStatusAsync"/> to check the status of the task.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_delete/?language=csharp</remarks>
-        Task<AsyncOperationResponse> DeleteChannelsAsync(IEnumerable<string> cids, bool hardDelete = false);
+        Task<AsyncOperationResponse> DeleteChannelsAsync(IEnumerable<string> cids, bool hardDelete = false, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Updates channels in batch based on the provided options.</para>
         /// This is an asynchronous operation and the returned value is a task Id.
         /// You can use <see cref="ITaskClient.GetTaskStatusAsync"/> to check the status of the task.
         /// </summary>
-        Task<AsyncOperationResponse> UpdateChannelsBatchAsync(ChannelsBatchOptions options);
+        Task<AsyncOperationResponse> UpdateChannelsBatchAsync(ChannelsBatchOptions options, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Returns a <see cref="ChannelBatchUpdater"/> instance for convenient batch channel operations.
@@ -66,7 +73,7 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// Takes away moderators status from given user ids.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/moderation/?language=csharp</remarks>
-        Task<ApiResponse> DemoteModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds);
+        Task<ApiResponse> DemoteModeratorsAsync(string channelType, string channelId, IEnumerable<string> userIds, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Mutes a channel.</para>
@@ -76,7 +83,7 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// of muted channels and their expiration time is returned when the user connects.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/muting_channels/?language=csharp</remarks>
-        Task<ChannelMuteResponse> MuteChannelAsync(ChannelMuteRequest request);
+        Task<ChannelMuteResponse> MuteChannelAsync(ChannelMuteRequest request, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Unmutes a channel.</para>
@@ -87,7 +94,7 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// This method removes the mute which means the users will receive notifications again.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/muting_channels/?language=csharp</remarks>
-        Task<ChannelUnmuteResponse> UnmuteChannelAsync(ChannelUnmuteRequest request);
+        Task<ChannelUnmuteResponse> UnmuteChannelAsync(ChannelUnmuteRequest request, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Export a channel and download all messages and metadata.</para>
@@ -96,7 +103,7 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// Use <see cref="GetExportChannelsStatusAsync"/> to check the status of the export.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/exporting_channels/?language=csharp</remarks>
-        Task<AsyncOperationResponse> ExportChannelAsync(ExportChannelItem request);
+        Task<AsyncOperationResponse> ExportChannelAsync(ExportChannelItem request, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Export of one or many channels and download all messages and metadata.</para>
@@ -105,13 +112,13 @@ Task<UpdateChannelResponse> AssignRolesAsync(string channelType, string channelI
         /// Use <see cref="GetExportChannelsStatusAsync"/> to check the status of the export.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/exporting_channels/?language=csharp</remarks>
-        Task<AsyncOperationResponse> ExportChannelsAsync(ExportChannelRequest request);
+        Task<AsyncOperationResponse> ExportChannelsAsync(ExportChannelRequest request, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Returns the status of a channel export. It contains the URL to the JSON file.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/exporting_channels/?language=csharp</remarks>
-        Task<ExportChannelsStatusResponse> GetExportChannelsStatusAsync(string taskId);
+        Task<ExportChannelsStatusResponse> GetExportChannelsStatusAsync(string taskId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Returns a channel. If it doesn't exist yet with the given name, it will be created.
@@ -125,35 +132,35 @@ Task<ChannelGetResponse> GetOrCreateAsync(string channelType, string channelId,
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/creating_channels/?language=csharp</remarks>
         Task<ChannelGetResponse> GetOrCreateAsync(string channelType, string channelId,
-            ChannelGetRequest channelRequest);
+            ChannelGetRequest channelRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Returns a channel. If it doesn't exist yet with the given name, it will be created.
         /// This overload creates or gets a channel without explicit channel id.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/creating_channels/?language=csharp</remarks>
-        Task<ChannelGetResponse> GetOrCreateAsync(string channelType, ChannelGetRequest channelRequest);
+        Task<ChannelGetResponse> GetOrCreateAsync(string channelType, ChannelGetRequest channelRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Removes a channel from query channel requests for that user until a new message is added.</para>
         /// Use <see cref="ShowAsync"/> to cancel this operation.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/muting_channels/?language=csharp</remarks>
-        Task<ApiResponse> HideAsync(string channelType, string channelId, string userId, bool clearHistory = false);
+        Task<ApiResponse> HideAsync(string channelType, string channelId, string userId, bool clearHistory = false, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Shows a previously hidden channel.</para>
         /// Use <see cref="HideAsync"/> to hide a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/muting_channels/?language=csharp</remarks>
-        Task<ApiResponse> ShowAsync(string channelType, string channelId, string userId);
+        Task<ApiResponse> ShowAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Can be used to set and unset specific fields when it is necessary to retain additional custom data fields on the object.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_update/?language=csharp</remarks>
         Task<PartialUpdateChannelResponse> PartialUpdateAsync(string channelType, string channelId,
-            PartialUpdateChannelRequest partialUpdateChannelRequest);
+            PartialUpdateChannelRequest partialUpdateChannelRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Queries channels.</para>
@@ -163,7 +170,7 @@ Task<PartialUpdateChannelResponse> PartialUpdateAsync(string channelType, string
         /// You can find the complete list of supported operators in the query syntax section of the docs.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/query_channels/?language=csharp</remarks>
-        Task<QueryChannelResponse> QueryChannelsAsync(QueryChannelsOptions opts);
+        Task<QueryChannelResponse> QueryChannelsAsync(QueryChannelsOptions opts, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Queries members of a channel.</para>
@@ -173,26 +180,26 @@ Task<PartialUpdateChannelResponse> PartialUpdateAsync(string channelType, string
         /// you want to search members or if you want to display the full list of members for a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/query_members/?language=csharp</remarks>
-        Task<QueryMembersResponse> QueryMembersAsync(QueryMembersRequest queryMembersRequest);
+        Task<QueryMembersResponse> QueryMembersAsync(QueryMembersRequest queryMembersRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Removes member(s) from a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_members/?language=csharp</remarks>
         Task<ApiResponse> RemoveMembersAsync(string channelType, string channelId, IEnumerable<string> userIds,
-            MessageRequest msg = null);
+            MessageRequest msg = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Adds filter tags to a channel.
         /// </summary>
-        Task<UpdateChannelResponse> AddFilterTagsAsync(string channelType, string channelId, IEnumerable<string> filterTags, MessageRequest msg = null);
+        Task<UpdateChannelResponse> AddFilterTagsAsync(string channelType, string channelId, IEnumerable<string> filterTags, MessageRequest msg = null, CancellationToken cancellationToken = default);
 
         Task<UpdateChannelResponse> AddFilterTagsAsync(string channelType, string channelId, params string[] filterTags);
 
         /// <summary>
         /// Removes filter tags from a channel.
         /// </summary>
-        Task<ApiResponse> RemoveFilterTagsAsync(string channelType, string channelId, IEnumerable<string> filterTags, MessageRequest msg = null);
+        Task<ApiResponse> RemoveFilterTagsAsync(string channelType, string channelId, IEnumerable<string> filterTags, MessageRequest msg = null, CancellationToken cancellationToken = default);
 
         Task<ApiResponse> RemoveFilterTagsAsync(string channelType, string channelId, params string[] filterTags);
 
@@ -201,53 +208,53 @@ Task<ApiResponse> RemoveMembersAsync(string channelType, string channelId, IEnum
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_member/#update-channel-members</remarks>
         Task<ChannelMemberResponse> UpdateMemberPartialAsync(string channelType, string channelId,
-            ChannelMemberPartialRequest channelMemberPartialRequest);
+            ChannelMemberPartialRequest channelMemberPartialRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Removes all messages but not affect the channel data or channel members.</para>
         /// If you want to delete both channel and message data then use <see cref="DeleteAsync"/> method instead.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/truncate_channel/?language=csharp</remarks>
-        Task<TruncateResponse> TruncateAsync(string channelType, string channelId);
+        Task<TruncateResponse> TruncateAsync(string channelType, string channelId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Removes all messages but not affect the channel data or channel members.</para>
         /// If you want to delete both channel and message data then use <see cref="DeleteAsync"/> method instead.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/truncate_channel/?language=csharp</remarks>
-        Task<TruncateResponse> TruncateAsync(string channelType, string channelId, TruncateOptions truncateOptions);
+        Task<TruncateResponse> TruncateAsync(string channelType, string channelId, TruncateOptions truncateOptions, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Invites a user to the channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_invites/?language=csharp/</remarks>
         Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, string userId,
-            MessageRequest msg = null);
+            MessageRequest msg = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Invites a user to the channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_invites/?language=csharp/</remarks>
-        Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds);
+        Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Invites a user to the channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_invites/?language=csharp/</remarks>
         Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IEnumerable<string> userIds,
-            MessageRequest msg = null);
+            MessageRequest msg = null, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Accepts an invitaton to a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_invites/?language=csharp/</remarks>
-        Task<UpdateChannelResponse> AcceptInviteAsync(string channelType, string channelId, string userId);
+        Task<UpdateChannelResponse> AcceptInviteAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Rejects an invitaton to a channel.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_invites/?language=csharp/</remarks>
-        Task<UpdateChannelResponse> RejectInviteAsync(string channelType, string channelId, string userId);
+        Task<UpdateChannelResponse> RejectInviteAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// <para>Updates a channel.</para>
@@ -257,30 +264,30 @@ Task<UpdateChannelResponse> InviteAsync(string channelType, string channelId, IE
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_update/?language=csharp</remarks>
         Task<UpdateChannelResponse> UpdateAsync(string channelType, string channelId,
-            ChannelUpdateRequest updateRequest);
+            ChannelUpdateRequest updateRequest, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Pins the channel for the user.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_update/#pinning-a-channel</remarks>
-        Task<ChannelMemberResponse> PinAsync(string channelType, string channelId, string userId);
+        Task<ChannelMemberResponse> PinAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Unpins the channel for the user.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_update/#pinning-a-channel</remarks>
-        Task<ChannelMemberResponse> UnpinAsync(string channelType, string channelId, string userId);
+        Task<ChannelMemberResponse> UnpinAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Archives the channel for the user.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_update/#archiving-a-channel</remarks>
-        Task<ChannelMemberResponse> ArchiveAsync(string channelType, string channelId, string userId);
+        Task<ChannelMemberResponse> ArchiveAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Unarchives the channel for the user.
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/dotnet-csharp/channel_update/#archiving-a-channel</remarks>
-        Task<ChannelMemberResponse> UnarchiveAsync(string channelType, string channelId, string userId);
+        Task<ChannelMemberResponse> UnarchiveAsync(string channelType, string channelId, string userId, CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/Models/Channel.cs b/src/Models/Channel.cs
index dc8403fb..a76a6b0b 100644
--- a/src/Models/Channel.cs
+++ b/src/Models/Channel.cs
@@ -53,6 +53,7 @@ public class ChannelGetResponse : ApiResponse
     public class UpdateChannelResponse : ApiResponse
     {
         public ChannelWithConfig Channel { get; set; }
+        public bool? Hidden { get; set; }
         public Message Message { get; set; }
         public List<ChannelMember> Members { get; set; }
     }
diff --git a/src/Models/CustomDataBase.cs b/src/Models/CustomDataBase.cs
index 2d874aa6..0817c7cc 100644
--- a/src/Models/CustomDataBase.cs
+++ b/src/Models/CustomDataBase.cs
@@ -9,6 +9,11 @@ public abstract class CustomDataBase
         [JsonExtensionData]
         private IDictionary<string, JToken> _data = new Dictionary<string, JToken>();
 
+        /// <summary>
+        /// Gets the list of all keys which are present at the custom data.
+        /// </summary>
+        public IEnumerable<string> GetKeys() => _data.Keys;
+
         /// <summary>
         /// Gets a custom data value.
         /// </summary>
diff --git a/src/Rest/IRestClient.cs b/src/Rest/IRestClient.cs
index 49eff2a6..0e7d35b8 100644
--- a/src/Rest/IRestClient.cs
+++ b/src/Rest/IRestClient.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace StreamChat.Rest
@@ -12,6 +13,6 @@ RestRequest BuildRestRequest(string fullPath,
             IEnumerable<KeyValuePair<string, string>> queryParams = null,
             MultipartFormDataContent multipartBody = null);
 
-        Task<RestResponse> ExecuteAsync(RestRequest request);
+        Task<RestResponse> ExecuteAsync(RestRequest request, CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/Rest/RestClient.cs b/src/Rest/RestClient.cs
index 22cfeaad..acdbbba5 100644
--- a/src/Rest/RestClient.cs
+++ b/src/Rest/RestClient.cs
@@ -57,11 +57,12 @@ public RestRequest BuildRestRequest(string fullPath,
                 .AddQueryParametersIfNotNull(queryParams);
         }
 
-        public async Task<RestResponse> ExecuteAsync(RestRequest request)
+        public async Task<RestResponse> ExecuteAsync(RestRequest request, CancellationToken cancellationToken = default)
         {
             var uri = BuildUriWithQueryString(request);
 
-            using (var cancelTokenSource = new CancellationTokenSource(_timeout))
+            using (var cancelTokenSourceTimeout = new CancellationTokenSource(_timeout))
+            using (var cancelTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, cancelTokenSourceTimeout.Token))
             using (var req = GenerateRequestMessage(request, uri))
             {
                 var response = await _httpClient.SendAsync(req, cancelTokenSource.Token);
diff --git a/tests/ChannelClientTests.cs b/tests/ChannelClientTests.cs
index 11b99135..3c7c3aa6 100644
--- a/tests/ChannelClientTests.cs
+++ b/tests/ChannelClientTests.cs
@@ -229,7 +229,7 @@ public async Task TestMembersQueryAsync()
             await _channelClient.AddMembersAsync(channel.Type, channel.Id, userIds);
 
             // Invite members
-            await _channelClient.InviteAsync(channel.Type, channel.Id, userIdsToInvite);
+            await _channelClient.InviteAsync(channel.Type, channel.Id, userIdsToInvite, cancellationToken: default);
 
             // Ban members
             foreach (var userToBanId in usersToBan)
@@ -407,6 +407,7 @@ public async Task TestChannelUpdateAsync()
 
             var actualChannel = await _channelClient.UpdateAsync(_channel.Type, _channel.Id, expectedChannel);
 
+            actualChannel.Channel.GetKeys().Should().BeEquivalentTo(new[] { "plain", "complex" });
             actualChannel.Channel.GetData<string>("plain").Should()
                 .BeEquivalentTo(expectedChannel.Data.GetData<string>("plain"));
             actualChannel.Channel.GetData<string[]>("complex").Should()
@@ -423,6 +424,7 @@ public async Task TestChannelPartialUpdateAsync()
 
             var actualChannel = await _channelClient.PartialUpdateAsync(_channel.Type, _channel.Id, channelUpdates);
 
+            actualChannel.Channel.GetKeys().Should().BeEquivalentTo(new[] { "color", "age" });
             actualChannel.Channel.GetData<string>("color").Should().BeEquivalentTo((string)channelUpdates.Set["color"]);
             actualChannel.Channel.GetData<int>("age").Should().Be((int)channelUpdates.Set["age"]);
         }
@@ -557,7 +559,7 @@ await _channelClient.UnmuteChannelAsync(new ChannelUnmuteRequest
         public async Task TestGetExportChannelAsync()
         {
             var resp = await _channelClient.ExportChannelAsync(new ExportChannelItem
-                { Id = _channel.Id, Type = _channel.Type });
+            { Id = _channel.Id, Type = _channel.Type });
 
             await WaitForAsync(async () =>
             {