diff --git a/src/Discord.Net/API/DiscordAPIClient.cs b/src/Discord.Net/API/DiscordAPIClient.cs
index 8bcd4b079..357c2c06a 100644
--- a/src/Discord.Net/API/DiscordAPIClient.cs
+++ b/src/Discord.Net/API/DiscordAPIClient.cs
@@ -764,10 +764,10 @@ namespace Discord.API
             Preconditions.NotEqual(guildId, 0, nameof(guildId));
             Preconditions.NotNull(args, nameof(args));
             Preconditions.GreaterThan(args.Limit, 0, nameof(args.Limit));
-            Preconditions.AtLeast(args.Offset, 0, nameof(args.Offset));
+            Preconditions.GreaterThan(args.AfterUserId, 0, nameof(args.AfterUserId));
 
             int limit = args.Limit.GetValueOrDefault(int.MaxValue);
-            int offset = args.Offset.GetValueOrDefault(0);
+            ulong afterUserId = args.AfterUserId.GetValueOrDefault(0);
 
             List<GuildMember[]> result;
             if (args.Limit.IsSpecified)
@@ -778,7 +778,7 @@ namespace Discord.API
             while (true)
             {
                 int runLimit = (limit >= DiscordConfig.MaxUsersPerBatch) ? DiscordConfig.MaxUsersPerBatch : limit;
-                string endpoint = $"guilds/{guildId}/members?limit={runLimit}&offset={offset}";
+                string endpoint = $"guilds/{guildId}/members?limit={runLimit}&after={afterUserId}";
                 var models = await SendAsync<GuildMember[]>("GET", endpoint, options: options).ConfigureAwait(false);
 
                 //Was this an empty batch?
@@ -787,7 +787,7 @@ namespace Discord.API
                 result.Add(models);
 
                 limit -= DiscordConfig.MaxUsersPerBatch;
-                offset += models.Length;
+                afterUserId = models[models.Length - 1].User.Id;
 
                 //Was this an incomplete (the last) batch?
                 if (models.Length != DiscordConfig.MaxUsersPerBatch) break;
diff --git a/src/Discord.Net/API/Rest/GetGuildMembersParams.cs b/src/Discord.Net/API/Rest/GetGuildMembersParams.cs
index bf4be2ee0..3df756d29 100644
--- a/src/Discord.Net/API/Rest/GetGuildMembersParams.cs
+++ b/src/Discord.Net/API/Rest/GetGuildMembersParams.cs
@@ -3,6 +3,6 @@
     public class GetGuildMembersParams
     {
         public Optional<int> Limit { get; set; }
-        public Optional<int> Offset { get; set; }
+        public Optional<ulong> AfterUserId { get; set; }
     }
 }
diff --git a/src/Discord.Net/Entities/Channels/DMChannel.cs b/src/Discord.Net/Entities/Channels/DMChannel.cs
index b940397ad..a5adc4284 100644
--- a/src/Discord.Net/Entities/Channels/DMChannel.cs
+++ b/src/Discord.Net/Entities/Channels/DMChannel.cs
@@ -58,12 +58,7 @@ namespace Discord
         public virtual async Task<IReadOnlyCollection<IUser>> GetUsersAsync()
         {
             var currentUser = await Discord.GetCurrentUserAsync().ConfigureAwait(false);
-            return ImmutableArray.Create<IUser>(currentUser, Recipient);
-        }
-        public virtual async Task<IReadOnlyCollection<IUser>> GetUsersAsync(int limit, int offset)
-        {
-            var currentUser = await Discord.GetCurrentUserAsync().ConfigureAwait(false);
-            return new IUser[] { currentUser, Recipient }.Skip(offset).Take(limit).ToImmutableArray();
+            return ImmutableArray.Create(currentUser, Recipient);
         }
 
         public async Task<IMessage> SendMessageAsync(string text, bool isTTS)
diff --git a/src/Discord.Net/Entities/Channels/GuildChannel.cs b/src/Discord.Net/Entities/Channels/GuildChannel.cs
index 78838d242..3c96e230b 100644
--- a/src/Discord.Net/Entities/Channels/GuildChannel.cs
+++ b/src/Discord.Net/Entities/Channels/GuildChannel.cs
@@ -65,7 +65,6 @@ namespace Discord
 
         public abstract Task<IGuildUser> GetUserAsync(ulong id);
         public abstract Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync();
-        public abstract Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset);
 
         public async Task<IReadOnlyCollection<IInviteMetadata>> GetInvitesAsync()
         {
@@ -151,6 +150,5 @@ namespace Discord
 
         async Task<IUser> IChannel.GetUserAsync(ulong id) => await GetUserAsync(id).ConfigureAwait(false);
         async Task<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync() => await GetUsersAsync().ConfigureAwait(false);
-        async Task<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(int limit, int offset) => await GetUsersAsync(limit, offset).ConfigureAwait(false);
     }
 }
diff --git a/src/Discord.Net/Entities/Channels/IChannel.cs b/src/Discord.Net/Entities/Channels/IChannel.cs
index f27504e94..53c681b56 100644
--- a/src/Discord.Net/Entities/Channels/IChannel.cs
+++ b/src/Discord.Net/Entities/Channels/IChannel.cs
@@ -7,8 +7,6 @@ namespace Discord
     {
         /// <summary> Gets a collection of all users in this channel. </summary>
         Task<IReadOnlyCollection<IUser>> GetUsersAsync();
-        /// <summary> Gets a paginated collection of all users in this channel. </summary>
-        Task<IReadOnlyCollection<IUser>> GetUsersAsync(int limit, int offset = 0);
         /// <summary> Gets a user in this channel with the provided id.</summary>
         Task<IUser> GetUserAsync(ulong id);
     }
diff --git a/src/Discord.Net/Entities/Channels/TextChannel.cs b/src/Discord.Net/Entities/Channels/TextChannel.cs
index c32b67c74..e7ead481f 100644
--- a/src/Discord.Net/Entities/Channels/TextChannel.cs
+++ b/src/Discord.Net/Entities/Channels/TextChannel.cs
@@ -52,11 +52,6 @@ namespace Discord
             var users = await Guild.GetUsersAsync().ConfigureAwait(false);
             return users.Where(x => Permissions.GetValue(Permissions.ResolveChannel(x, this, x.GuildPermissions.RawValue), ChannelPermission.ReadMessages)).ToImmutableArray();
         }
-        public override async Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset)
-        {
-            var users = await Guild.GetUsersAsync(limit, offset).ConfigureAwait(false);
-            return users.Where(x => Permissions.GetValue(Permissions.ResolveChannel(x, this, x.GuildPermissions.RawValue), ChannelPermission.ReadMessages)).ToImmutableArray();
-        }
 
         public async Task<IMessage> SendMessageAsync(string text, bool isTTS)
         {
diff --git a/src/Discord.Net/Entities/Channels/VoiceChannel.cs b/src/Discord.Net/Entities/Channels/VoiceChannel.cs
index a7e32d5a4..eb7c0840a 100644
--- a/src/Discord.Net/Entities/Channels/VoiceChannel.cs
+++ b/src/Discord.Net/Entities/Channels/VoiceChannel.cs
@@ -45,10 +45,6 @@ namespace Discord
         {
             throw new NotSupportedException();
         }
-        public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset)
-        {
-            throw new NotSupportedException();
-        }
 
         public virtual Task<IAudioClient> ConnectAsync() { throw new NotSupportedException(); }
 
diff --git a/src/Discord.Net/Entities/Guilds/Guild.cs b/src/Discord.Net/Entities/Guilds/Guild.cs
index 3eed4ce8f..1e400cce0 100644
--- a/src/Discord.Net/Entities/Guilds/Guild.cs
+++ b/src/Discord.Net/Entities/Guilds/Guild.cs
@@ -279,12 +279,6 @@ namespace Discord
             var models = await Discord.ApiClient.GetGuildMembersAsync(Id, args).ConfigureAwait(false);
             return models.Select(x => new GuildUser(this, new User(x.User), x)).ToImmutableArray();
         }
-        public virtual async Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset)
-        {
-            var args = new GetGuildMembersParams { Limit = limit, Offset = offset };
-            var models = await Discord.ApiClient.GetGuildMembersAsync(Id, args).ConfigureAwait(false);
-            return models.Select(x => new GuildUser(this, new User(x.User), x)).ToImmutableArray();
-        }
         public async Task<int> PruneUsersAsync(int days = 30, bool simulate = false)
         {
             var args = new GuildPruneParams() { Days = days };
diff --git a/src/Discord.Net/Entities/Messages/Message.cs b/src/Discord.Net/Entities/Messages/Message.cs
index 1ac7a14f3..225890578 100644
--- a/src/Discord.Net/Entities/Messages/Message.cs
+++ b/src/Discord.Net/Entities/Messages/Message.cs
@@ -157,9 +157,7 @@ namespace Discord
                 model = await Discord.ApiClient.ModifyMessageAsync(guildChannel.Guild.Id, Channel.Id, Id, args).ConfigureAwait(false);
             else
                 model = await Discord.ApiClient.ModifyDMMessageAsync(Channel.Id, Id, args).ConfigureAwait(false);
-        {
-            await Discord.ApiClient.AddPinAsync(Channel.Id, Id).ConfigureAwait(false);
-        }
+                
             Update(model, UpdateSource.Rest);
         }        
         public async Task DeleteAsync()
diff --git a/src/Discord.Net/Entities/WebSocket/CachedDMChannel.cs b/src/Discord.Net/Entities/WebSocket/CachedDMChannel.cs
index ed3eadac9..dae7cf92d 100644
--- a/src/Discord.Net/Entities/WebSocket/CachedDMChannel.cs
+++ b/src/Discord.Net/Entities/WebSocket/CachedDMChannel.cs
@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Linq;
 using System.Threading.Tasks;
 using MessageModel = Discord.API.Message;
 using Model = Discord.API.Channel;
@@ -26,8 +25,6 @@ namespace Discord
 
         public override Task<IUser> GetUserAsync(ulong id) => Task.FromResult<IUser>(GetUser(id));
         public override Task<IReadOnlyCollection<IUser>> GetUsersAsync() => Task.FromResult<IReadOnlyCollection<IUser>>(Members);
-        public override Task<IReadOnlyCollection<IUser>> GetUsersAsync(int limit, int offset) 
-            => Task.FromResult<IReadOnlyCollection<IUser>>(Members.Skip(offset).Take(limit).ToImmutableArray());
         public ICachedUser GetUser(ulong id)
         {
             var currentUser = Discord.CurrentUser;
diff --git a/src/Discord.Net/Entities/WebSocket/CachedGuild.cs b/src/Discord.Net/Entities/WebSocket/CachedGuild.cs
index d4c5153b4..5e96181e5 100644
--- a/src/Discord.Net/Entities/WebSocket/CachedGuild.cs
+++ b/src/Discord.Net/Entities/WebSocket/CachedGuild.cs
@@ -179,9 +179,6 @@ namespace Discord
             => Task.FromResult<IGuildUser>(CurrentUser);
         public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync() 
             => Task.FromResult<IReadOnlyCollection<IGuildUser>>(Members);
-        //TODO: Is there a better way of exposing pagination?
-        public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset) 
-            => Task.FromResult<IReadOnlyCollection<IGuildUser>>(Members.OrderBy(x => x.Id).Skip(offset).Take(limit).ToImmutableArray());
         public CachedGuildUser AddUser(MemberModel model, DataStore dataStore, ConcurrentDictionary<ulong, CachedGuildUser> members = null)
         {
             members = members ?? _members;
diff --git a/src/Discord.Net/Entities/WebSocket/CachedTextChannel.cs b/src/Discord.Net/Entities/WebSocket/CachedTextChannel.cs
index 7a91a8221..48c51c761 100644
--- a/src/Discord.Net/Entities/WebSocket/CachedTextChannel.cs
+++ b/src/Discord.Net/Entities/WebSocket/CachedTextChannel.cs
@@ -28,8 +28,6 @@ namespace Discord
 
         public override Task<IGuildUser> GetUserAsync(ulong id) => Task.FromResult<IGuildUser>(GetUser(id));
         public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync() => Task.FromResult<IReadOnlyCollection<IGuildUser>>(Members);
-        public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset)
-            => Task.FromResult<IReadOnlyCollection<IGuildUser>>(Members.Skip(offset).Take(limit).ToImmutableArray());
         public CachedGuildUser GetUser(ulong id, bool skipCheck = false)
         {
             var user = Guild.GetUser(id);
diff --git a/src/Discord.Net/Entities/WebSocket/CachedVoiceChannel.cs b/src/Discord.Net/Entities/WebSocket/CachedVoiceChannel.cs
index 358464188..c0de8915d 100644
--- a/src/Discord.Net/Entities/WebSocket/CachedVoiceChannel.cs
+++ b/src/Discord.Net/Entities/WebSocket/CachedVoiceChannel.cs
@@ -25,8 +25,6 @@ namespace Discord
             => Task.FromResult(GetUser(id));
         public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync() 
             => Task.FromResult(Members);
-        public override Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(int limit, int offset) 
-            => Task.FromResult<IReadOnlyCollection<IGuildUser>>(Members.OrderBy(x => x.Id).Skip(offset).Take(limit).ToImmutableArray());
         public IGuildUser GetUser(ulong id)
         {
             var user = Guild.GetUser(id);
diff --git a/src/Discord.Net/Entities/WebSocket/MessageManager.cs b/src/Discord.Net/Entities/WebSocket/MessageManager.cs
index 98fde21b0..ea9ec11c8 100644
--- a/src/Discord.Net/Entities/WebSocket/MessageManager.cs
+++ b/src/Discord.Net/Entities/WebSocket/MessageManager.cs
@@ -61,7 +61,7 @@ namespace Discord
                 };
                 var downloadedMessages = await _discord.ApiClient.GetChannelMessagesAsync(_channel.Id, args).ConfigureAwait(false);
 
-                var guild = (_channel as ICachedGuildChannel).Guild;
+                var guild = (_channel as ICachedGuildChannel)?.Guild;
                 return cachedMessages.Concat(downloadedMessages.Select(x =>
                 {
                     IUser user = _channel.GetUser(x.Author.Value.Id, true);