diff --git a/src/entities/channel-section.ts b/src/entities/channel-section.ts
index efe8418a0..20a8749bf 100644
--- a/src/entities/channel-section.ts
+++ b/src/entities/channel-section.ts
@@ -13,7 +13,7 @@ export class ChannelSection {
   /**
    * The parts to request for this entity.
    */
-  public static part = 'snippet,contentDetails'
+  public static part = 'contentDetails,snippet'
 
   /**
    * The fields to request for this entity.
diff --git a/src/entities/channel.ts b/src/entities/channel.ts
index ba833f241..8e71d4551 100644
--- a/src/entities/channel.ts
+++ b/src/entities/channel.ts
@@ -13,7 +13,8 @@ export class Channel {
   /**
    * The parts to request for this entity.
    */
-  public static part = 'snippet,contentDetails,statistics,status,brandingSettings,localizations'
+  public static part =
+    'brandingSettings,contentDetails,localizations,snippet,statistics,status'
 
   /**
    * The fields to request for this entity.
@@ -322,8 +323,8 @@ export class Channel {
   */
   public async unsubscribe (subscriptionResolvable?: SubscriptionResolvable, myId?: string) {
     const subscription = subscriptionResolvable ?
-      await this.youtube._resolutionService.resolve(subscriptionResolvable, Subscription) :
-      await this.youtube._subscriptionService.getSubscriptionByChannels(
+      await this.youtube._services.resolution.resolve(subscriptionResolvable, Subscription) :
+      await this.youtube.getSubscriptionByChannels(
         myId ?? (await this.youtube.oauth.getMe()).id, this.id
       )
 
diff --git a/src/entities/index.ts b/src/entities/index.ts
index b1a8636ae..a52f6b82f 100644
--- a/src/entities/index.ts
+++ b/src/entities/index.ts
@@ -4,6 +4,7 @@
  */
 
 export * from './video'
+export * from './video-rating'
 export * from './channel'
 export * from './playlist'
 export * from './comment'
diff --git a/src/entities/playlist.ts b/src/entities/playlist.ts
index c781cd9cb..9a8b7700e 100644
--- a/src/entities/playlist.ts
+++ b/src/entities/playlist.ts
@@ -13,7 +13,7 @@ export class Playlist {
   /**
    * The parts to request for this entity.
    */
-  public static part = 'snippet,contentDetails,player,status'
+  public static part = 'contentDetails,player,snippet,status'
 
   /**
    * The fields to request for this entity.
@@ -199,7 +199,7 @@ export class Playlist {
    * @param note A note on the video.
    */
   public async addVideo (videoResolvable: VideoResolvable, position?: number, note?: string) {
-    const videoId = await this.youtube._resolutionService.resolve(videoResolvable, Video)
+    const videoId = await this.youtube._services.resolution.resolve(videoResolvable, Video)
     const playlistItem = await this.youtube.oauth.playlists.addPlaylistItem(
       this, videoId, position, note)
 
@@ -218,8 +218,8 @@ export class Playlist {
    * @param itemId The playlist item ID if you have it.
    */
   public async updateVideo (videoResolvable: VideoResolvable, position?: number, note?: string, itemId?: string) {
-    const video = await this.youtube._resolutionService.resolve(videoResolvable, Video)
-    const playlistItemId = itemId ?? (await this.youtube._genericService.getPaginatedItems({
+    const video = await this.youtube._services.resolution.resolve(videoResolvable, Video)
+    const playlistItemId = itemId ?? (await this.youtube._services.retrieval.getPaginatedItems({
       type: PaginatedItemType.PlaylistItems,
       mine: false,
       id: this.id,
@@ -238,16 +238,22 @@ export class Playlist {
    * @param videoResolvable The URL, ID, or (not recommended) search query of the video.
    */
   public async removeVideo (videoResolvable: VideoResolvable) {
-    const video = await this.youtube._resolutionService.resolve(videoResolvable, Video)
-    const playlistItemId = (this.youtube._genericService.getPaginatedItems({
+    const video = await this.youtube._services.resolution.resolve(videoResolvable, Video)
+    const matchingItems = (await this.youtube._services.retrieval.getPaginatedItems<Video>({
       type: PaginatedItemType.PlaylistItems,
       mine: false,
       id: this.id,
-      maxPerPage: 1,
       subId: typeof video === 'string' ? video : video.id
-    }))[0].id
+    })).items
+
+    if (!matchingItems.length) {
+      return Promise.reject(
+        new Error('The requested video was not found in the playlist')
+      )
+    }
 
-    return this.removeItem(playlistItemId)
+    // Remove by playlist item ID, not video ID
+    return this.removeItem(matchingItems[0].data.id)
   }
 
   /**
diff --git a/src/entities/subscription.ts b/src/entities/subscription.ts
index 79cc1bf02..8f708d4c3 100644
--- a/src/entities/subscription.ts
+++ b/src/entities/subscription.ts
@@ -14,7 +14,7 @@ export class Subscription {
   /**
    * The parts to request for this entity.
    */
-  public static part = 'snippet,contentDetails,subscriberSnippet'
+  public static part = 'contentDetails,snippet,subscriberSnippet'
 
   /**
    * The fields to request for this entity.
diff --git a/src/entities/video-rating.ts b/src/entities/video-rating.ts
new file mode 100644
index 000000000..1d1874a01
--- /dev/null
+++ b/src/entities/video-rating.ts
@@ -0,0 +1,79 @@
+import { YouTube } from '..'
+
+/**
+ * A YouTube [Video](./Library_Exports.Video) rating (like/dislike).
+ */
+export class VideoRating {
+  /**
+   * The name of the endpoint used for this entity.
+   */
+  public static endpoint = 'videos/getRating'
+
+  /**
+   * The parts to request for this entity.
+   */
+  public static part = ''
+
+  /**
+   * The fields to request for this entity.
+   */
+  public static fields = 'items(videoId,rating)'
+
+  /**
+   * The YouTube object that created this channel section object.
+   */
+  public youtube: YouTube
+
+  /**
+   * Whether or not this a full channel section object.
+   */
+  public full = true
+
+  /**
+   * The raw data of this channel section.
+   */
+  public data: any
+
+  /**
+   * The ID of the video this rating is for.
+   */
+  public videoId: string
+
+  /**
+   * The rating left on this video.
+   */
+  public rating: 'like' | 'dislike' | 'none' | 'unspecified'
+
+  constructor (youtube: YouTube, data: any, full = true) {
+    this.youtube = youtube
+    this.data = data
+
+    this._init(data)
+  }
+
+  /**
+   * @ignore
+   */
+  private _init (data: any) {
+    // Currently broken in the API
+    /* if (data.kind !== 'youtube#videoGetRatingResponse') {
+      throw new Error(`Invalid video rating type: ${data.kind}`)
+    } */
+
+    if (!data.videoId || !data.rating) {
+      throw new Error('Invalid video rating')
+    }
+
+    this.videoId = data.videoId
+    this.rating = data.rating
+  }
+
+  /**
+   * Fetches this video rating from the API and reassigns this object to the new rating object.
+   * Only useful if you want updated rating info.
+   */
+  public async fetch () {
+    const rating = await this.youtube.oauth.videos.getMyRatings(this.videoId)
+    return Object.assign(this, rating)
+  }
+}
diff --git a/src/entities/video.ts b/src/entities/video.ts
index 4b410e3dd..d8bda4950 100644
--- a/src/entities/video.ts
+++ b/src/entities/video.ts
@@ -16,7 +16,8 @@ export class Video {
   /**
    * The parts to request for this entity.
    */
-  public static part = 'snippet,contentDetails,statistics,status,recordingDetails,localizations'
+  public static part =
+    'contentDetails,localizations,recordingDetails,snippet,statistics,status'
 
   /**
    * The fields to request for this entity.
@@ -311,8 +312,8 @@ export class Video {
    * Must be using an access token with correct scopes.
    */
   public async getRating (): Promise<'like' | 'dislike' | 'none' | 'unspecified'> {
-    const response = await this.youtube.oauth.videos.getMyRatings([ this.id ])
-    return response[0].rating
+    const response = await this.youtube.oauth.videos.getMyRatings(this.id)
+    return response.rating
   }
 
   /**
diff --git a/src/index.ts b/src/index.ts
index a8436193a..011dab5da 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -34,37 +34,26 @@ export class YouTube {
   /**
    * @ignore
    */
-  public _request: Request
-
-  /**
-   * @ignore
-   */
-  public _upload: Request
+  public _cacheCheckInterval: number
 
   /**
    * @ignore
    */
-  public _searchService = new Service.SearchService(this)
-
-  /**
-   * @ignore
-   */
-  public _subscriptionService = new Service.SubscriptionService(this)
-
-  /**
-   * @ignore
-   */
-  public _channelService = new Service.ChannelService(this)
+  public _request: Request
 
   /**
    * @ignore
    */
-  public _resolutionService = new Service.ResolutionService(this)
+  public _upload: Request
 
   /**
    * @ignore
    */
-  public _genericService = new Service.GenericService(this)
+  public _services = {
+    search: new Service.SearchService(this),
+    resolution: new Service.ResolutionService(this),
+    retrieval: new Service.RetrievalService(this)
+  }
 
   #auth: T.Authorization = {}
 
@@ -98,7 +87,7 @@ export class YouTube {
     this.#auth.accessToken = accessToken
 
     if (!this.#auth.accessToken && !this.#auth.apiKey) {
-      throw new TypeError('Must include one of api key or access token whenever constructing the YouTube object.')
+      throw new TypeError('Must include one of API key or access token whenever constructing the YouTube object.')
     }
 
     if (options.request) {
@@ -113,27 +102,70 @@ export class YouTube {
     this._upload = new Request('https://www.googleapis.com/upload/youtube/v3/', this.#auth)
     this.oauth = new OAuth(this)
 
-    this._shouldCache = options.cache
-    this._cacheSearches = options.cacheSearches
-    this._cacheTTL = options.cacheTTL
+    this._shouldCache = options.cache ?? true
+    this._cacheSearches = options.cacheSearches ?? true
+    this._cacheTTL = options.cacheTTL ?? 600
+    this._cacheCheckInterval = options.cacheCheckInterval ?? 600
 
     this.language = language
     this.region = region
 
-    if (options.cacheCheckInterval > 0) {
-      setInterval(Cache.checkTTLs, options.cacheCheckInterval * 1000)
+    if (this._cacheCheckInterval > 0) {
+      setInterval(Cache.checkTTLs, this._cacheCheckInterval * 1000)
+    }
+  }
+
+  /**
+   * @ignore
+   */
+  public _cacheItem (type: T.ItemTypes, name: string, value: InstanceType<T.ItemTypes>,
+    parts?: string[]) {
+    if (!this._shouldCache) {
+      return
+    }
+
+    Cache.setItem(type, name, value,
+      this._cacheTTL > 0 ? this._cacheTTL * 1000 + new Date().getTime() : 0, parts)
+  }
+
+  /**
+   * @ignore
+   */
+  public _cacheItems (type: T.ItemTypes, names: string[],
+    values: InstanceType<T.ItemTypes>[], parts?: string[]) {
+    if (!this._shouldCache) {
+      return
     }
+
+    Cache.setItems(type, names, values,
+      this._cacheTTL > 0 ? this._cacheTTL * 1000 + new Date().getTime() : 0, parts)
   }
 
   /**
    * @ignore
    */
-  public _cache (id: string, value: any) {
+  public _cacheResolution<T extends T.ResolvableClass = T.ResolvableClass>
+  (type: T, input: string, value: T.Resolvable<T>) {
     if (!this._shouldCache) {
       return
     }
 
-    Cache.set(id, value, this._cacheTTL > 0 ? this._cacheTTL * 1000 + new Date().getTime() : 0)
+    Cache.setResolution(type, input, value,
+      this._cacheTTL > 0 ? this._cacheTTL * 1000 + new Date().getTime() : 0)
+  }
+
+  /**
+   * @ignore
+   */
+  public _cachePage (endpoint: string, page: number, options: T.PaginatedRequestParams,
+    auth: T.AuthorizationOptions | undefined, parts: string[] | undefined,
+    type: T.PaginatedType | undefined, value: T.PaginatedResponse<T.PaginatedInstance>) {
+    if (!this._shouldCache) {
+      return
+    }
+
+    Cache.setPage(endpoint, page, options, auth, parts, type, value,
+      this._cacheTTL > 0 ? this._cacheTTL * 1000 + new Date().getTime() : 0)
   }
 
   /**
@@ -145,7 +177,7 @@ export class YouTube {
    */
   public async search<T extends T.SearchType = T.SearchType> (searchTerm: string, searchOptions?: T.GenericSearchOptions<T>):
   Promise<T.PaginatedResponse<InstanceType<T>>> {
-    return this._searchService.search({ searchTerm, ...searchOptions?.searchFilters, ...searchOptions?.pageOptions })
+    return this._services.search.search({ searchTerm, ...searchOptions?.searchFilters, ...searchOptions?.pageOptions })
   }
 
   /**
@@ -178,7 +210,10 @@ export class YouTube {
    * Defaults to the maximum 50 items per page, as well as 1 page. Increase pages as high as you'd like.
    */
   public async searchPlaylists (searchTerm: string, searchOptions?: T.EntitySearchOptions<typeof Entity.Playlist>) {
-    return this.search(searchTerm, { searchFilters: { ...searchOptions?.searchFilters, types: [Entity.Playlist] }, pageOptions: searchOptions?.pageOptions })
+    return this.search(searchTerm, {
+      searchFilters: { ...searchOptions?.searchFilters, types: [Entity.Playlist] },
+      pageOptions: searchOptions?.pageOptions
+    })
   }
 
   /**
@@ -187,8 +222,8 @@ export class YouTube {
    * @param parts The parts of the video to fetch (saves quota if you aren't using certain properties!)
    */
   public async getVideo<T extends T.VideoResolvable | T.VideoResolvable[]> (videoResolvable: T, parts?: Part.VideoParts) {
-    const video = await this._resolutionService.resolve(videoResolvable, Entity.Video)
-    return this._genericService.getItem(Entity.Video, false, video, parts)
+    const video = await this._services.resolution.resolve(videoResolvable, Entity.Video)
+    return this._services.retrieval.getItem(Entity.Video, { resolvableEntity: video }, parts)
   }
 
   /**
@@ -199,8 +234,8 @@ export class YouTube {
    * @param parts The parts of the channel to fetch (saves quota if you aren't using certain properties!)
    */
   public async getChannel<T extends T.ChannelResolvable | T.ChannelResolvable[]> (channelResolvable: T, parts?: Part.ChannelParts) {
-    const channel = await this._resolutionService.resolve(channelResolvable, Entity.Channel)
-    return this._genericService.getItem(Entity.Channel, false, channel, parts)
+    const channel = await this._services.resolution.resolve(channelResolvable, Entity.Channel)
+    return this._services.retrieval.getItem(Entity.Channel, { resolvableEntity: channel }, parts)
   }
 
   /**
@@ -210,8 +245,8 @@ export class YouTube {
    * @param parts The parts of the playlist to fetch (saves quota if you aren't using certain properties!)
    */
   public async getPlaylist<T extends T.PlaylistResolvable | T.PlaylistResolvable[]> (playlistResolvable: T, parts?: Part.PlaylistParts) {
-    const playlist = await this._resolutionService.resolve(playlistResolvable, Entity.Playlist)
-    return this._genericService.getItem(Entity.Playlist, false, playlist, parts)
+    const playlist = await this._services.resolution.resolve(playlistResolvable, Entity.Playlist)
+    return this._services.retrieval.getItem(Entity.Playlist, { resolvableEntity: playlist }, parts)
   }
 
   /**
@@ -220,7 +255,7 @@ export class YouTube {
    * @param parts The parts of the comment to fetch (saves quota if you aren't using certain properties!)
    */
   public async getComment<T extends string | string[]> (commentId: T, parts?: Part.CommentParts) {
-    return this._genericService.getItem(Entity.Comment, false, commentId, parts)
+    return this._services.retrieval.getItem(Entity.Comment, { resolvableEntity: commentId }, parts)
   }
 
   /**
@@ -231,7 +266,7 @@ export class YouTube {
    * @param parts The parts of the subscription to fetch (saves quota if you aren't using certain properties!)
    */
   public async getSubscription<T extends string | string[]> (subscriptionId: T, parts?: Part.SubscriptionParts) {
-    return this._genericService.getItem(Entity.Subscription, false, subscriptionId, parts)
+    return this._services.retrieval.getItem(Entity.Subscription, { resolvableEntity: subscriptionId }, parts)
   }
 
   /**
@@ -239,7 +274,7 @@ export class YouTube {
    * @param categoryId The ID of the category.
    */
   public async getCategory<T extends string | string[]> (categoryId: T) {
-    return this._genericService.getItem(Entity.VideoCategory, false, categoryId)
+    return this._services.retrieval.getItem(Entity.VideoCategory, { resolvableEntity: categoryId })
   }
 
   /**
@@ -248,7 +283,7 @@ export class YouTube {
    * @param parts The parts of the channel section to fetch (saves quota if you aren't using certain properties!)
    */
   public async getChannelSection<T extends string | string[]> (sectionId: T, parts?: Part.ChannelSectionParts) {
-    return this._genericService.getItem(Entity.ChannelSection, false, sectionId, parts)
+    return this._services.retrieval.getItem(Entity.ChannelSection, { resolvableEntity: sectionId }, parts)
   }
 
   /**
@@ -259,9 +294,20 @@ export class YouTube {
    * @param parts The parts of the subscription to fetch (saves quota if you aren't using certain properties!)
    */
   public async getSubscriptionByChannels (subscriberResolvable: T.ChannelResolvable, channelResolvable: T.ChannelResolvable, parts?: Part.SubscriptionParts) {
-    const subscriberAndChannel = (await this._resolutionService.resolve([ subscriberResolvable, channelResolvable ], Entity.Channel))
+    const subscriberAndChannel = (await this._services.resolution
+      .resolve([ subscriberResolvable, channelResolvable ], Entity.Channel))
       .map(channel => typeof channel === 'string' ? channel : channel.id)
-    return this._subscriptionService.getSubscriptionByChannels(subscriberAndChannel[0], subscriberAndChannel[1], parts)
+
+    return this._services.retrieval.getPaginatedItems<Entity.Subscription>({
+      type: T.PaginatedItemType.Subscriptions,
+      id: subscriberAndChannel[0],
+      subId: subscriberAndChannel[1],
+      maxPerPage: 1
+    }).then(results =>
+      results.items.length ?
+        results.items[0] :
+        Promise.reject(new Error('Subscription not found'))
+    )
   }
 
   /**
@@ -275,8 +321,8 @@ export class YouTube {
    * @returns An object containing page token information for future requests and ***partial* video objects**.
    */
   public async getPlaylistItems (playlistResolvable: T.PlaylistResolvable, pageOptions?: T.PageOptions, parts?: Part.PlaylistItemParts) {
-    const playlist = await this._resolutionService.resolve(playlistResolvable, Entity.Playlist)
-    return this._genericService.getPaginatedItems<Entity.Video>(
+    const playlist = await this._services.resolution.resolve(playlistResolvable, Entity.Playlist)
+    return this._services.retrieval.getPaginatedItems<Entity.Video>(
       { type: T.PaginatedItemType.PlaylistItems, id: typeof playlist === 'string' ? playlist : playlist.id, ...pageOptions, parts }
     )
   }
@@ -294,8 +340,8 @@ export class YouTube {
   public async getVideoComments (videoResolvable: T.VideoResolvable, pageOptions?: T.PageOptions,
     order?: 'time' | 'relevance', parts?: Part.CommentThreadParts) {
 
-    const video = await this._resolutionService.resolve(videoResolvable, Entity.Video)
-    return this._genericService.getPaginatedItems<Entity.Comment>(
+    const video = await this._services.resolution.resolve(videoResolvable, Entity.Video)
+    return this._services.retrieval.getPaginatedItems<Entity.Comment>(
       { type: T.PaginatedItemType.VideoComments, id: typeof video === 'string' ? video : video.id, ...pageOptions, parts, order })
   }
 
@@ -310,8 +356,8 @@ export class YouTube {
    * @returns An object containing page token information for future requests and **playlist objects**.
    */
   public async getChannelPlaylists (channelResolvable: T.ChannelResolvable, pageOptions?: T.PageOptions, parts?: Part.PlaylistParts) {
-    const channel = await this._resolutionService.resolve(channelResolvable, Entity.Channel)
-    return this._genericService.getPaginatedItems<Entity.Playlist>(
+    const channel = await this._services.resolution.resolve(channelResolvable, Entity.Channel)
+    return this._services.retrieval.getPaginatedItems<Entity.Playlist>(
       { type: T.PaginatedItemType.Playlists, id: typeof channel === 'string' ? channel : channel.id, ...pageOptions, parts })
   }
 
@@ -326,8 +372,8 @@ export class YouTube {
    * @returns An object containing page token information for future requests and **subscription objects**.
    */
   public async getChannelSubscriptions (channelResolvable: T.ChannelResolvable, pageOptions?: T.PageOptions, parts?: Part.SubscriptionParts) {
-    const channel = await this._resolutionService.resolve(channelResolvable, Entity.Channel)
-    return this._genericService.getPaginatedItems<Entity.Subscription>(
+    const channel = await this._services.resolution.resolve(channelResolvable, Entity.Channel)
+    return this._services.retrieval.getPaginatedItems<Entity.Subscription>(
       { type: T.PaginatedItemType.Subscriptions, id: typeof channel === 'string' ? channel : channel.id, ...pageOptions, parts })
   }
 
@@ -342,8 +388,8 @@ export class YouTube {
    * @returns An object containing page token information for future requests and **comment objects**.
    */
   public async getCommentReplies (commentResolvable: T.CommentResolvable, pageOptions?: T.PageOptions, parts?: Part.CommentParts) {
-    const comment = await this._resolutionService.resolve(commentResolvable, Entity.Comment)
-    return this._genericService.getPaginatedItems<Entity.Comment>(
+    const comment = await this._services.resolution.resolve(commentResolvable, Entity.Comment)
+    return this._services.retrieval.getPaginatedItems<Entity.Comment>(
       { type: T.PaginatedItemType.CommentReplies, id: typeof comment === 'string' ? comment : comment.id, ...pageOptions, parts })
   }
 
@@ -355,8 +401,8 @@ export class YouTube {
    * @returns Partial channel section objects.
    */
   public async getChannelSections (channelResolvable: T.ChannelResolvable, parts?: Part.ChannelSectionParts) {
-    const channel = await this._resolutionService.resolve(channelResolvable, Entity.Channel)
-    return (await this._genericService.getPaginatedItems<Entity.ChannelSection>(
+    const channel = await this._services.resolution.resolve(channelResolvable, Entity.Channel)
+    return (await this._services.retrieval.getPaginatedItems<Entity.ChannelSection>(
       { type: T.PaginatedItemType.ChannelSections, id: typeof channel === 'string' ? channel : channel.id, parts })).items
   }
 
@@ -364,21 +410,21 @@ export class YouTube {
    * Get the list of video categories in [`this.region`](#region)`.
    */
   public async getCategories () {
-    return (await this._genericService.getPaginatedItems({ type: T.PaginatedItemType.VideoCategories })).items as Entity.VideoCategory[]
+    return (await this._services.retrieval.getPaginatedItems({ type: T.PaginatedItemType.VideoCategories })).items as Entity.VideoCategory[]
   }
 
   /**
    * Get a list of languages that YouTube supports.
    */
   public async getLanguages () {
-    return (await this._genericService.getPaginatedItems({ type: T.PaginatedItemType.Languages })).items as Entity.Language[]
+    return (await this._services.retrieval.getPaginatedItems({ type: T.PaginatedItemType.Languages })).items as Entity.Language[]
   }
 
   /**
    * Get a list of regions that YouTube supports.
    */
   public async getRegions () {
-    return (await this._genericService.getPaginatedItems({ type: T.PaginatedItemType.Regions })).items as Entity.Region[]
+    return (await this._services.retrieval.getPaginatedItems({ type: T.PaginatedItemType.Regions })).items as Entity.Region[]
   }
 
   public hasAccessToken () {
diff --git a/src/oauth/captions.ts b/src/oauth/captions.ts
index 82062c767..042fe17d6 100644
--- a/src/oauth/captions.ts
+++ b/src/oauth/captions.ts
@@ -10,17 +10,22 @@ export class OAuthCaptions {
   constructor (public oauth: OAuth) {}
 
   /**
-   * Get a [Caption](./Library_Exports.Caption#) object from the ID of the caption.  
-   * Last tested 06/11/2020 04:50. PASSING
+   * Get a [Caption](./Library_Exports.Caption#) object
+   * from the URL, ID, or search query of its video and the ID of the caption.  
    * @param videoResolvable The Title, URL, or ID of the video to get the caption from.
    * @param captionId The ID of the caption.
    */
   public async getCaption (videoResolvable: YT.VideoResolvable, captionId: string): Promise<YT.Caption> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
+    const params: { videoId: string; id?: string } =
+      { videoId: typeof video === 'string' ? video : video.id }
+
+    if (captionId) params.id = captionId
+
     const data = await this.oauth.youtube._request.get('captions', {
-      params: { part: 'snippet', videoId: typeof video === 'string' ? video : video.id, id: captionId },
+      params: { part: 'snippet', id: captionId },
       authorizationOptions: { accessToken: true }
     })
 
@@ -33,13 +38,12 @@ export class OAuthCaptions {
 
   /**
    * Gets the [Caption](./Library_Exports.Caption#)s of a [Video](./Library_Exports.Video#). Used mostly internally with [Video.fetchCaptions](./Library_Exports.Video#fetchCaptions).  
-   * Last tested 06/11/2020 04:50. PASSING
    * @param videoResolvable The Title, URL, or ID of the video to get the captions from.
    */
   public async getCaptions (videoResolvable: YT.VideoResolvable): Promise<YT.Caption[]> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
     const data = await this.oauth.youtube._request.get('captions', {
       params: { part: 'snippet', videoId: typeof video === 'string' ? video : video.id },
       authorizationOptions: { accessToken: true }
@@ -54,7 +58,6 @@ export class OAuthCaptions {
 
   /**
    * Uploads a [Caption](./Library_Exports.Caption#) track for a [Video](./Library_Exports.Video#).  
-   * Last tested 06/11/2020 04:50. PASSING
    * @param videoResolvable The video to add the caption track to.
    * @param language The language that the caption track is in.
    * @param name The name of the caption track.
@@ -64,7 +67,7 @@ export class OAuthCaptions {
   public async uploadCaption (videoResolvable: YT.VideoResolvable, language: string, name: string, track: Buffer, draft: boolean = false): Promise<YT.Caption> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
     const data: typeof Data.CAPTION_DATA = JSON.parse(JSON.stringify(Data.CAPTION_DATA))
 
     data.snippet = {
@@ -89,7 +92,6 @@ export class OAuthCaptions {
    * Edits a [Caption](./Library_Exports.Caption#) track.  
    * **If your request does not specify a value for a property that already has a value,
    * the property's existing value will be deleted.**  
-   * Last tested 06/11/2020 04:50. PASSING
    * @param id The ID of the caption track to edit.
    * @param track The caption track to upload.
    * @param draft Whether or not the caption track is a draft. If it is, it isn't visible to users.
@@ -134,7 +136,6 @@ export class OAuthCaptions {
 
   /**
    * Downloads a [Caption](./Library_Exports.Caption#) track.  
-   * Last tested 06/11/2020 04:50. PASSING
    * @param id The ID of the caption track to download.
    * @param format The file format to download the track in.
    * @param language The language to download the track in.
@@ -160,7 +161,6 @@ export class OAuthCaptions {
 
   /**
    * Deletes a [Caption](./Library_Exports.Caption#) track.  
-   * Last tested 06/11/2020 04:50. PASSING
    * @param id The ID of the caption track to delete.
    */
   public deleteCaption (id: string): Promise<void> {
diff --git a/src/oauth/channels.ts b/src/oauth/channels.ts
index 2647db6a2..9dd64604b 100644
--- a/src/oauth/channels.ts
+++ b/src/oauth/channels.ts
@@ -13,14 +13,13 @@ export class OAuthChannels {
    * Updates a channel's branding settings.
    * **If your request does not specify a value for a property that already has a value,
    * the property's existing value will be deleted.**  
-   * Last tested NEVER
    * @param channelResolvable The channel to update the branding settings of.
    * @param brandingSettings The new branding settings.
    */
   public async updateChannelBranding (channelResolvable: YT.ChannelResolvable, brandingSettings: YT.ChannelBrandingSettings): Promise<YT.Channel> {
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
     const data: typeof Data.CHANNEL_DATA = JSON.parse(JSON.stringify(Data.CHANNEL_DATA))
 
     data.id = typeof channel === 'string' ? channel : channel.id
@@ -39,7 +38,6 @@ export class OAuthChannels {
    * **CURRENTLY BROKEN in the API**
    * **If your request does not specify a value for a property that already has a value,
    * the property's existing value will be deleted.**  
-   * Last tested 05/20/2020 02:58. PASSING
    * @param channelResolvable The channel to update the localizations of.
    * @param localizations The new localizations.
    */
@@ -48,7 +46,7 @@ export class OAuthChannels {
 
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
     const data: typeof Data.CHANNEL_DATA = JSON.parse(JSON.stringify(Data.CHANNEL_DATA))
 
     data.id = typeof channel === 'string' ? channel : channel.id
@@ -64,14 +62,13 @@ export class OAuthChannels {
 
   /**
    * Sets a channel as made for kids or not made for kids.  
-   * Last tested 05/20/2020 02:58. PASSING
    * @param channelResolvable The channel to update.
    * @param madeForKids Whether or not the channel is made for kids.
    */
   public async setChannelMadeForKids (channelResolvable: YT.ChannelResolvable, madeForKids: boolean): Promise<YT.Channel> {
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
     const data: typeof Data.CHANNEL_DATA = JSON.parse(JSON.stringify(Data.CHANNEL_DATA))
 
     data.id = typeof channel === 'string' ? channel : channel.id
@@ -89,7 +86,6 @@ export class OAuthChannels {
 
   /**
    * Sets a channel's watermark.  
-   * Last tested 05/19/2020 18:07. PASSING
    * @param channelResolvable The channel to set the watermark for.
    * @param type The timing type of the watermark.
    * @param offset The offset, in milliseconds, from the start/end of the video to display the watermark from.
@@ -101,7 +97,7 @@ export class OAuthChannels {
 
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
     const data: typeof Data.WATERMARK_DATA = JSON.parse(JSON.stringify(Data.WATERMARK_DATA))
 
     data.timing = {
@@ -122,13 +118,12 @@ export class OAuthChannels {
 
   /**
    * Unsets a channel's watermark.  
-   * Last tested 05/18/2020 18:23. PASSING
    * @param channelResolvable The channel to unset the watermark from.
    */
   public async unsetChannelWatermark (channelResolvable: YT.ChannelResolvable): Promise<void> {
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
     return this.oauth.youtube._request.post('watermarks/unset', {
       params: { channelId: typeof channel === 'string' ? channel : channel.id },
       authorizationOptions: { accessToken: true }
@@ -137,7 +132,6 @@ export class OAuthChannels {
 
   /**
    * Uploads a channel banner.  
-   * Last tested 05/20/2020 03:17. PASSING
    * @param image The channel banner to upload.
    * @returns The URL of the uploaded banner, used as
    * [`BrandingSettings.image.bannerExternalUrl`](../modules/Library_Exports#channelbrandingsettings)
@@ -155,7 +149,6 @@ export class OAuthChannels {
 
   /**
    * Adds a [ChannelSection](./Library_Exports.ChannelSection#) to the authorized user's [Channel](./Library_Exports.Channel#).  
-   * Last tested 05/24/2020 10:11. PASSING
    * @param type The type of channel section.
    * @param name The name of the channel section.
    * @param position The position of the channel section on the channel homepage.
@@ -167,9 +160,9 @@ export class OAuthChannels {
     this.oauth.checkTokenAndThrow()
 
     const resolvedPlaylists =
-      playlistsResolvable ? await Promise.all(playlistsResolvable.map(v => this.oauth.youtube._resolutionService.resolve(v, YT.Playlist))) : undefined
+      playlistsResolvable ? await Promise.all(playlistsResolvable.map(v => this.oauth.youtube._services.resolution.resolve(v, YT.Playlist))) : undefined
     const resolvedChannels =
-      channelsResolvable? await Promise.all(channelsResolvable.map(v => this.oauth.youtube._resolutionService.resolve(v, YT.Channel))) : undefined
+      channelsResolvable? await Promise.all(channelsResolvable.map(v => this.oauth.youtube._services.resolution.resolve(v, YT.Channel))) : undefined
 
     const data: typeof Data.CHANNEL_SECTION_DATA = JSON.parse(JSON.stringify(Data.CHANNEL_SECTION_DATA))
     const parts: string[] = [ 'id', 'snippet' ]
@@ -206,7 +199,6 @@ export class OAuthChannels {
    * Updates a [ChannelSection](./Library_Exports.ChannelSection#).
    * **If your request does not specify a value for a property that already has a value,
    * the property's existing value will be deleted.**  
-   * Last tested 05/24/2020 10:11. PASSING
    * @param id The ID of the channel section.
    * @param type The type of channel section.
    * @param style The style of the channel section.
@@ -223,9 +215,9 @@ export class OAuthChannels {
     this.oauth.checkTokenAndThrow()
 
     const resolvedPlaylists =
-      playlistsResolvable ? await Promise.all(playlistsResolvable.map(v => this.oauth.youtube._resolutionService.resolve(v, YT.Playlist))) : undefined
+      playlistsResolvable ? await Promise.all(playlistsResolvable.map(v => this.oauth.youtube._services.resolution.resolve(v, YT.Playlist))) : undefined
     const resolvedChannels =
-      channelsResolvable? await Promise.all(channelsResolvable.map(v => this.oauth.youtube._resolutionService.resolve(v, YT.Channel))) : undefined
+      channelsResolvable? await Promise.all(channelsResolvable.map(v => this.oauth.youtube._services.resolution.resolve(v, YT.Channel))) : undefined
 
     const data: typeof Data.CHANNEL_SECTION_DATA = JSON.parse(JSON.stringify(Data.CHANNEL_SECTION_DATA))
     const parts: string[] = [ 'id', 'snippet' ]
@@ -251,7 +243,6 @@ export class OAuthChannels {
 
   /**
    * Deletes a [ChannelSection](./Library_Exports.ChannelSection#).
-   * Last tested 05/24/2020 10:11. PASSING
    * @param id The ID of the channel section.
    */
   public deleteChannelSection (id: string): Promise<YT.ChannelSection> {
@@ -264,14 +255,13 @@ export class OAuthChannels {
 
   /**
    * Subscribe to a [Channel](./Library_Exports.Channel#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param channelResolvable The channel to subscribe to.
    * @returns A partial subscription object.
    */
   public async subscribeToChannel (channelResolvable: YT.ChannelResolvable): Promise<YT.Subscription> {
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
     const data: typeof Data.SUBSCRIPTION_DATA = JSON.parse(JSON.stringify(Data.SUBSCRIPTION_DATA))
 
     data.snippet.resourceId.channelId = typeof channel === 'string' ? channel : channel.id
@@ -286,7 +276,6 @@ export class OAuthChannels {
 
   /**
    * Unsubscribe from a [Channel](./Library_Exports.Channel#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param channelId The channel to unsubscribe from.
    */
   public unsubscribeFromChannel (subscriptionId: string): Promise<void> {
diff --git a/src/oauth/comments.ts b/src/oauth/comments.ts
index 71d494858..7b13849fd 100644
--- a/src/oauth/comments.ts
+++ b/src/oauth/comments.ts
@@ -11,7 +11,6 @@ export class OAuthComments {
 
   /**
    * Post a [Comment](./Library_Exports.Comment#) on a [Video](./Library_Exports.Video#) or [Channel](./Library_Exports.Channel#) discussion.  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param text The text content of the comment.
    * @param channelResolvable The channel to post the comment on.
    * @param videoResolvable The video of the channel to post the comment on.
@@ -20,8 +19,8 @@ export class OAuthComments {
   public async postComment (text: string, channelResolvable: YT.ChannelResolvable, videoResolvable: YT.VideoResolvable): Promise<YT.Comment> {
     this.oauth.checkTokenAndThrow()
 
-    const channel = await this.oauth.youtube._resolutionService.resolve(channelResolvable, YT.Channel)
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const channel = await this.oauth.youtube._services.resolution.resolve(channelResolvable, YT.Channel)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
     const data: typeof Data.COMMENT_THREAD_DATA = JSON.parse(JSON.stringify(Data.COMMENT_THREAD_DATA))
 
     data.snippet.topLevelComment.snippet.textOriginal = text
@@ -39,7 +38,6 @@ export class OAuthComments {
 
   /**
    * Replies to a [Comment](./Library_Exports.Comment#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param commentId The ID of the comment to reply to.
    * @param text The text to reply with.
    * Required for [Comment.url](./Library_Exports.Comment#url) to be correct.
@@ -60,7 +58,6 @@ export class OAuthComments {
 
   /**
    * Edit a [Comment](./Library_Exports.Comment#) on a [Video](./Library_Exports.Video#) or [Channel](./Library_Exports.Channel#) discussion.  
-   * Last tested 07/05/2021 17:40. PASSING
    * @param commentId The ID of the comment.
    * @param text The new text content of the comment.
    */
@@ -83,7 +80,6 @@ export class OAuthComments {
 
   /**
    * Marks a [Comment](./Library_Exports.Comment#) as spam.  
-   * Last tested NEVER
    * @param commentId The ID of the comment to mark as spam.
    */
   public markCommentAsSpam (commentId: string): Promise<void> {
@@ -96,7 +92,6 @@ export class OAuthComments {
 
   /**
    * Sets the moderation status of a [Comment](./Library_Exports.Comment#)  
-   * Last tested NEVER
    * @param commentId The ID of the comment to set the moderation status of.
    * @param moderationStatus The moderation status to set the comment to.
    * @param banAuthor Whether or not to ban the author from making future comments.
@@ -125,7 +120,6 @@ export class OAuthComments {
 
   /**
    * Deletes a [Comment](./Library_Exports.Comment#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param id The ID of the comment to delete.
    */
   public deleteComment (commentId: string): Promise<void> {
diff --git a/src/oauth/index.ts b/src/oauth/index.ts
index 5e6174350..33a06213b 100644
--- a/src/oauth/index.ts
+++ b/src/oauth/index.ts
@@ -68,11 +68,10 @@ export class OAuth {
 
   /**
    * Gets the authorized user's [Channel](./Library_Exports.Channel#).  
-   * Last tested 05/18/2020 11:48. PASSING
    */
   public getMe (parts?: Part.ChannelParts): Promise<YT.Channel> {
     this.checkTokenAndThrow()
-    return this.youtube._genericService.getItem(YT.Channel, true, null, parts) as Promise<YT.Channel>
+    return this.youtube._services.retrieval.getItem(YT.Channel, { mine: true }, parts)
   }
 
   /**
@@ -81,7 +80,6 @@ export class OAuth {
    * meaning they are missing some data. See the properties they include [here](https://developers.google.com/youtube/v3/docs/playlistItems#resource-representation).
    * Use [`YouTube.getVideo(playlist.videos)`](./Library_Exports.YouTube#getvideo) to
    * fetch the full objects while not spamming your quota like you would using a loop.  
-   * Last tested NEVER
    * @param pageOptions The number of pages and maximum number of items per page.
    * Fetches the maximum number of items allowed by the API per page by default.  
    * Set pages to a value <=0 to fetch all.
@@ -98,7 +96,6 @@ export class OAuth {
 
   /**
    * Gets the authorized user's [Subscription](./Library_Exports.Subscription#)s.  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param pageOptions The number of pages and maximum number of items per page.
    * Fetches the maximum number of items allowed by the API per page by default.  
    * Set pages to a value <=0 to fetch
@@ -108,14 +105,14 @@ export class OAuth {
   public getMySubscriptions (pageOptions?: YT.PageOptions, parts?: Part.SubscriptionParts) {
     this.checkTokenAndThrow()
 
-    return this.youtube._genericService.getPaginatedItems<YT.Subscription>(
-      { type: YT.PaginatedItemType.Subscriptions, mine: true, parts, ...pageOptions }
+    return this.youtube._services.retrieval.getPaginatedItems<YT.Subscription>(
+      { type: YT.PaginatedItemType.Subscriptions, mine: true, parts, ...pageOptions },
+      { accessToken: true }
     )
   }
 
   /**
    * Gets the authorized user's [Playlist](./Library_Exports.Playlist#)s.  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param pageOptions The number of pages and maximum number of items per page.
    * Fetches the maximum number of items allowed by the API per page by default.  
    * Set pages to a value <=0 to fetch
@@ -125,20 +122,21 @@ export class OAuth {
   public getMyPlaylists (pageOptions?: YT.PageOptions, parts?: Part.PlaylistParts) {
     this.checkTokenAndThrow()
 
-    return this.youtube._genericService.getPaginatedItems<YT.Playlist>(
-      { type: YT.PaginatedItemType.Playlists, mine: true, parts, ...pageOptions }
+    return this.youtube._services.retrieval.getPaginatedItems<YT.Playlist>(
+      { type: YT.PaginatedItemType.Playlists, mine: true, parts, ...pageOptions },
+      { accessToken: true }
     )
   }
 
   /**
    * Gets the authorized user's [ChannelSection](./Library_Exports.ChannelSection)s.  
-   * Last tested 05/18/2020 11:48. PASSING
    */
   public async getMyChannelSections (parts?: Part.ChannelSectionParts) {
     this.checkTokenAndThrow()
 
-    return (await this.youtube._genericService.getPaginatedItems<YT.ChannelSection>(
-      { type: YT.PaginatedItemType.ChannelSections, mine: true, parts }
+    return (await this.youtube._services.retrieval.getPaginatedItems<YT.ChannelSection>(
+      { type: YT.PaginatedItemType.ChannelSections, mine: true, parts },
+      { accessToken: true }
     )).items
   }
 }
diff --git a/src/oauth/playlists.ts b/src/oauth/playlists.ts
index 8fbfdb43a..01b65c3b6 100644
--- a/src/oauth/playlists.ts
+++ b/src/oauth/playlists.ts
@@ -11,7 +11,6 @@ export class OAuthPlaylists {
 
   /**
    * Creates a [Playlist](./Library_Exports.Playlist#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param title A title for the playlist.
    * @param description A description of the playlist.
    * @param privacy Whether the video is private, public, or unlisted.
@@ -50,7 +49,6 @@ export class OAuthPlaylists {
    * Updates a [Playlist](./Library_Exports.Playlist#).  
    * **If your request does not specify a value for a property that already has a value,
    * the property's existing value will be deleted.**  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param playlistResolvable The playlist to update.
    * @param title A title for the playlist.
    * @param description A description of the playlist.
@@ -65,7 +63,7 @@ export class OAuthPlaylists {
 
     this.oauth.checkTokenAndThrow()
 
-    const playlist = await this.oauth.youtube._resolutionService.resolve(playlistResolvable, YT.Playlist)
+    const playlist = await this.oauth.youtube._services.resolution.resolve(playlistResolvable, YT.Playlist)
     const data: typeof Data.PLAYLIST_DATA = JSON.parse(JSON.stringify(Data.PLAYLIST_DATA))
     const parts: string[] = [ 'id', 'player', 'snippet' ]
 
@@ -91,13 +89,12 @@ export class OAuthPlaylists {
 
   /**
    * Deletes a [Playlist](./Library_Exports.Playlist#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param playlistResolvable The playlist to delete.
    */
   public async deletePlaylist (playlistResolvable: YT.PlaylistResolvable): Promise<void> {
     this.oauth.checkTokenAndThrow()
 
-    const playlist = await this.oauth.youtube._resolutionService.resolve(playlistResolvable, YT.Playlist)
+    const playlist = await this.oauth.youtube._services.resolution.resolve(playlistResolvable, YT.Playlist)
     return this.oauth.youtube._request.delete('playlists', {
       params: { id: typeof playlist === 'string' ? playlist : playlist.id },
       authorizationOptions: { accessToken: true }
@@ -106,7 +103,6 @@ export class OAuthPlaylists {
 
   /**
    * Adds a [Video](./Library_Exports.Video#) to a [Playlist](./Library_Exports.Playlist#).  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param playlistResolvable The playlist to add the video to.
    * @param videoResolvable The video to add to the playlist.
    * @param position The position to add the video in. Defaults to the end.
@@ -118,8 +114,8 @@ export class OAuthPlaylists {
 
     this.oauth.checkTokenAndThrow()
 
-    const playlist = await this.oauth.youtube._resolutionService.resolve(playlistResolvable, YT.Playlist)
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const playlist = await this.oauth.youtube._services.resolution.resolve(playlistResolvable, YT.Playlist)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
 
     const data: typeof Data.PLAYLIST_ITEM_DATA = JSON.parse(JSON.stringify(Data.PLAYLIST_ITEM_DATA))
     const parts: string[] = [ 'id', 'snippet' ]
@@ -144,7 +140,6 @@ export class OAuthPlaylists {
    * Edits a playlist item.  
    * **If your request does not specify a value for a property that already has a value,
    * the property's existing value will be deleted.**  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param id The ID of the playlist item to edit.
    * @param playlistResolvable The playlist that the video is in.
    * @param videoResolvable The video that's in the playlist.
@@ -157,8 +152,8 @@ export class OAuthPlaylists {
 
     this.oauth.checkTokenAndThrow()
 
-    const playlist = await this.oauth.youtube._resolutionService.resolve(playlistResolvable, YT.Playlist)
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const playlist = await this.oauth.youtube._services.resolution.resolve(playlistResolvable, YT.Playlist)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
 
     const data: typeof Data.PLAYLIST_ITEM_DATA = JSON.parse(JSON.stringify(Data.PLAYLIST_ITEM_DATA))
     const parts: string[] = [ 'id', 'snippet' ]
@@ -182,7 +177,6 @@ export class OAuthPlaylists {
 
   /**
    * Deletes a playlist item.  
-   * Last tested 05/18/2020 11:48. PASSING
    * @param id The ID of the playlist item to delete.
    */
   public deletePlaylistItem (id: string): Promise<void> {
diff --git a/src/oauth/videos.ts b/src/oauth/videos.ts
index 4b11ebc66..940bde788 100644
--- a/src/oauth/videos.ts
+++ b/src/oauth/videos.ts
@@ -11,14 +11,14 @@ export class OAuthVideos {
 
   /**
    * Like, dislike, or remove a rating from a [Video](./Library_Exports.Video#).
-   * Last tested 05/18/2020 11:48. PASSING
    * @param videoResolvable The video to rate.
    * @param rating The rating to give the video.
    */
   public async rateVideo (videoResolvable: YT.VideoResolvable, rating: 'like' | 'dislike' | 'none'): Promise<void> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
+
     return this.oauth.youtube._request.post('videos/rate', {
       params: { id: typeof video === 'string' ? video : video.id, rating },
       authorizationOptions: { accessToken: true }
@@ -27,31 +27,56 @@ export class OAuthVideos {
 
   /**
      * Retrieve your rating on [Videos](./Library_Exports.Video#).  
-     * Last tested 05/18/2020 11:48. PASSING
-     * @param videoResolvables The video(s) to retrieve your rating from.
+     * @param videoResolvable The video(s) to retrieve your rating from.
      */
-  public async getMyRatings (videoResolvables: YT.VideoResolvable[]): Promise<{ videoId: string; rating: 'like' | 'dislike' | 'none' | 'unspecified' }[]> {
+  public async getMyRatings<T extends YT.VideoResolvable | YT.VideoResolvable[]>
+  (videoResolvable: T): Promise<T extends any[] ? YT.VideoRating[] : YT.VideoRating> {
     this.oauth.checkTokenAndThrow()
 
-    const videoIds = await Promise.all(videoResolvables.map(videoResolvable => this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)))
+    type ToReturn = T extends any[] ? YT.VideoRating[] : YT.VideoRating
+
+    const inputIsArray = Array.isArray(videoResolvable)
+    const resolvables: YT.VideoResolvable[] =
+      inputIsArray ? videoResolvable : [videoResolvable]
+
+    const videoIds = await Promise
+      .all(resolvables.map(resolvable =>
+        this.oauth.youtube._services.resolution.resolve(resolvable, YT.Video)))
+      .then(videos => videos.map(video => typeof video === 'string' ? video : video.id))
+
+    const alreadyResolved: YT.VideoRating[] = []
 
+    // Don't fetch already cached ratings
     if (this.oauth.youtube._shouldCache) {
-      const cached = Cache.get(`get://videos/getRating/${JSON.stringify(videoIds)}`)
-      if (cached) return cached
+      for (let i = 0; i < videoIds.length; i++) {
+        const cached = Cache.getItem(YT.VideoRating, videoIds[i])
+
+        if (cached) {
+          alreadyResolved.push(cached)
+          videoIds.splice(i--, 1)
+        }
+      }
     }
 
-    const response = await this.oauth.youtube._request.get('videos/getRating', {
-      params: { id: videoIds.join(',') },
-      authorizationOptions: { accessToken: true }
-    })
-    this.oauth.youtube._cache(`get://videos/getRating/${JSON.stringify(videoIds)}`, response.items)
+    // All of the ratings were cached, don't make a request
+    if (!videoIds.length) {
+      return (inputIsArray ? alreadyResolved : alreadyResolved[0]) as ToReturn
+    }
+
+    const ratings =
+      await this.oauth.youtube._services.retrieval.getPaginatedItems<YT.VideoRating>({
+        type: YT.PaginatedItemType.VideoRatings, id: videoIds.join(',')
+      }, { accessToken: true })
+
+    if (this.oauth.youtube._shouldCache) {
+      this.oauth.youtube._cacheItems(YT.VideoRating, videoIds, ratings.items)
+    }
 
-    return response.items
+    return (inputIsArray ? ratings.items : ratings.items[0]) as ToReturn
   }
 
   /**
      * Report a [Video](./Library_Exports.Video#) for abuse.  
-     * Last tested NEVER
      * @param videoResolvable The video to report.
      * @param reasonId The reason for reporting. (IDs can be found [here](https://developers.google.com/youtube/v3/docs/videoAbuseReportReasons/list))
      * @param secondaryReasonId An optional second reason for reporting.
@@ -61,7 +86,7 @@ export class OAuthVideos {
   public async reportAbuse (videoResolvable: YT.VideoResolvable, reasonId: string, secondaryReasonId?: string, comments?: string, language?: string): Promise<void> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
     const data: {
         videoId: string
         reasonId: string
@@ -85,13 +110,12 @@ export class OAuthVideos {
 
   /**
      * Deletes a [Video](./Library_Exports.Video#).
-     * Last tested NEVER
      * @param videoResolvable The video to delete.
      */
   public async deleteVideo (videoResolvable: YT.VideoResolvable): Promise<void> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
     return this.oauth.youtube._request.delete('videos', {
       params: { id: typeof video === 'string' ? video : video.id },
       authorizationOptions: { accessToken: true }
@@ -102,7 +126,6 @@ export class OAuthVideos {
      * Updates a [Video](./Library_Exports.Video#).  
      * **If your request does not specify a value for a property that already has a value,
      * the property's existing value will be deleted.**  
-     * Last tested NEVER
      * @param video The updated video object.
      */
   public async updateVideo (video: YT.VideoUpdateResource): Promise<YT.Video> {
@@ -142,14 +165,13 @@ export class OAuthVideos {
 
   /**
      * Sets a new [Thumbnail](../modules/Library_Exports#thumbnail) for a [Video](./Library_Exports.Video).  
-     * Last tested 05/18/2020 11:48. PASSING
      * @param videoResolvable The video to set the thumbnail for.
      * @param image The image data and type to upload.
      */
   public async setThumbnail (videoResolvable: YT.VideoResolvable, image: YT.Image): Promise<typeof YT.Video.prototype.thumbnails> {
     this.oauth.checkTokenAndThrow()
 
-    const video = await this.oauth.youtube._resolutionService.resolve(videoResolvable, YT.Video)
+    const video = await this.oauth.youtube._services.resolution.resolve(videoResolvable, YT.Video)
     const response = await this.oauth.youtube._upload.imagePost('thumbnails/set', {
       params: { videoId: typeof video === 'string' ? video : video.id },
       image,
@@ -161,11 +183,10 @@ export class OAuthVideos {
 
   /**
    * Gets a list of [VideoAbuseReportReason](./Library_Exports.VideoAbuseReportReason#)s.
-   * Last tested 05/18/2020 11:48. PASSING
    */
   public async getVideoAbuseReportReasons () {
     this.oauth.checkTokenAndThrow()
-    return (await this.oauth.youtube._genericService.getPaginatedItems(
+    return (await this.oauth.youtube._services.retrieval.getPaginatedItems(
       { type: YT.PaginatedItemType.VideoAbuseReportReasons },
       { accessToken: true })
     ).items as YT.VideoAbuseReportReason[]
diff --git a/src/services/channel-service.ts b/src/services/channel-service.ts
deleted file mode 100644
index 62513f647..000000000
--- a/src/services/channel-service.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { Cache } from '../util'
-import { ChannelParts } from '../types/Parts'
-import YouTube, { Channel } from '..'
-
-/**
- * @ignore
- */
-export class ChannelService {
-  constructor (private youtube: YouTube) {}
-
-  /**
-   * @deprecated Currently broken, not implemented in the current API
-   */
-  public async getChannelByUsername (username: string, parts?: ChannelParts): Promise<Channel> {
-    if (this.youtube._shouldCache) {
-      const cached = Cache.get(`channel_by_username://${username}`)
-      if (cached) return cached
-    }
-
-    const result = await this.youtube._request.get('channels', {
-      params: {
-        part: parts ? parts.join(',') : Channel.part,
-        forUsername: username
-      },
-      authorizationOptions: { apiKey: true }
-    })
-
-    if (!result.items?.length) {
-      return Promise.reject(new Error('Channel not found'))
-    }
-
-    const channel = new Channel(this.youtube, result.items[0], true)
-    this.youtube._cache(`channel_by_username://${username}`, channel)
-
-    return channel
-  }
-}
diff --git a/src/services/index.ts b/src/services/index.ts
index f6fd1f868..d9b285026 100644
--- a/src/services/index.ts
+++ b/src/services/index.ts
@@ -1,5 +1,3 @@
 export * from './search-service'
-export * from './generic-service'
-export * from './subscription-service'
-export * from './channel-service'
+export * from './retrieval-service'
 export * from './resolution-service'
diff --git a/src/services/resolution-service.ts b/src/services/resolution-service.ts
index feb4a30ba..b77ceb24d 100644
--- a/src/services/resolution-service.ts
+++ b/src/services/resolution-service.ts
@@ -1,5 +1,5 @@
 import { Cache, Parser } from '../util'
-import YouTube, { Channel, Comment, Playlist, Resolvable, ResolvableClass, ResolveReturn, SearchType, Subscription, Video, VideoCategory } from '..'
+import YouTube, { Channel, Comment, Playlist, Resolvable, ResolvableClass, ResolveReturn, Subscription, Video, VideoCategory } from '..'
 
 /**
  * @ignore
@@ -16,7 +16,8 @@ export class ResolutionService {
       else return this.resolveStringToIdOrEntity(input, type) as Promise<ResolveReturn<T, K>>
     }
 
-    const resolutions: (Resolvable<K> | Promise<Resolvable<K>>)[] = new Array(input.length) // either the ID or the input if resolution failed
+    // either the ID or the input if resolution failed
+    const resolutions: (Resolvable<K> | Promise<Resolvable<K>>)[] = new Array(input.length).fill(undefined)
     const resolvableStrings: { [resolutionIndex: number]: string } = {} // could be ID, URL, or search query
 
     let preresolvedCount = 0
@@ -50,23 +51,24 @@ export class ResolutionService {
    * **Anything that isn't an ID, Entity, or Username URL returns the first result of a search query of `type`.**
    */
   public async resolveStringToIdOrEntity<T extends ResolvableClass> (input: string, type: T): Promise<Resolvable<T>> {
-    if (this.youtube._shouldCache) {
-      const cached = Cache.get(`get_id://${type.endpoint}/${input}`)
-      if (cached) return cached
-    }
-
     // types that resolve only by class or ID
     if (type === VideoCategory || type === Comment || type === Subscription) {
       return input
     }
 
+    if (this.youtube._shouldCache) {
+      const cached = Cache.getResolution(type, input)
+      if (cached) return cached
+    }
+
     // The search query or ID parameter for later (used for setting legacy custom channel URL search query)
     let idOrSearchQuery = input
     let resolution: Resolvable<T>
 
     if (type === Channel && Parser.channelHandleRegex.test(input)) {
-      // Try to resolve as a username (custom channel handle)
-      resolution = await this.youtube._channelService.getChannelByUsername(input.slice(1)) as Resolvable<T>
+      // Try to search for the username (custom channel handles not implemented in API)
+      // At some point this can be used to get directly by handle if YouTube ever gets their crap together
+      idOrSearchQuery = input.slice(1)
       // Try to resolve as a URL
     } else if (Parser.youtubeUrlRegex.test(input)) {
       const resolvedUrl = await this.resolveUrl(input, type)
@@ -76,15 +78,16 @@ export class ResolutionService {
       else resolution = resolvedUrl.resolution
     }
 
-    // If the it's different from the original input, then it's a search query
+    // If it's different from the original input, then it's a search query
     // If we couldn't resolve as a URL then we want to try as an ID or search query
     if (idOrSearchQuery !== input || !resolution) {
       resolution = await this.resolveIdOrSearch(idOrSearchQuery, type)
     }
 
+    // If there are no search results and it couldn't be parsed, fallback to original input
     if (!resolution) resolution = input
 
-    this.youtube._cache(`get_id://${type.endpoint}/${input}`, resolution)
+    if (this.youtube._shouldCache) this.youtube._cacheResolution(type, input, resolution)
 
     return resolution
   }
@@ -104,9 +107,10 @@ export class ResolutionService {
       // we have to search for the legacy username and hope for the best
       return { searchQuery: parsedChannel.searchQuery }
     } else if (parsedChannel?.username) {
-      // But the new usernames (/@CustomUsername) work perfectly
-      const channel = await this.youtube._channelService.getChannelByUsername(parsedChannel.username) as InstanceType<T>
-      if (channel) return { resolution: channel }
+      // The new usernames are the same, but maybe one day we can use this like:
+      // const channel = await this.youtube._services.channel.getChannelByUsername(parsedChannel.username) as InstanceType<T>
+      // if (channel) return { resolution: channel }
+      return { searchQuery: parsedChannel.username }
     }
 
     return { resolution: parsedUrl[type.name.toLowerCase()]?.id }
@@ -120,9 +124,11 @@ export class ResolutionService {
     // Reasoning for these constraints: https://webapps.stackexchange.com/a/101153
     const isId = Parser[`${type.name.toLowerCase()}IdRegex`].test(input)
 
-    return isId ? input : this.youtube.search(input, {
+    if (isId) return input
+
+    return this.youtube.search(input, {
       pageOptions: { maxPerPage: 1 },
-      searchFilters: { types: [ type as SearchType ] }
+      searchFilters: { types: [ type ] }
     }).then(result => result.items.length ? result.items[0] : undefined) as InstanceType<T>
   }
 }
diff --git a/src/services/generic-service.ts b/src/services/retrieval-service.ts
similarity index 50%
rename from src/services/generic-service.ts
rename to src/services/retrieval-service.ts
index 75cbb9eab..5533847dc 100644
--- a/src/services/generic-service.ts
+++ b/src/services/retrieval-service.ts
@@ -1,323 +1,405 @@
-import { Cache } from '../util'
-import { ItemTypes, ItemReturns, PaginatedResponse, PaginatedItemType, PaginatedItemOptions,
-  PaginatedType, Resolvable, PaginatedInstance, PaginatedRequestParams, AuthorizationOptions } from '../types'
-import YouTube,
-{ Video, Channel, Playlist, Comment, VideoAbuseReportReason, Subscription, VideoCategory, Language, Region, ChannelSection, Caption } from '..'
-
-/**
- * @ignore
- */
-export class GenericService {
-  public readonly _getItemAllowedTypes = new Set([ Video, Channel, Playlist, Comment, Subscription, VideoCategory, ChannelSection, Caption ].map(c => c.name))
-  public readonly _getMineAllowed = new Set([ Playlist, Subscription, ChannelSection, Channel ].map(c => c.name))
-
-  constructor (private youtube: YouTube) {
-
-  }
-
-  public async getItem<T extends Resolvable<K> | Resolvable<K>[], K extends ItemTypes> (type: K, mine: boolean, id?: T, parts?: string[]):
-  Promise<ItemReturns<T, K>> {
-    if (!this._getItemAllowedTypes.has(type.name)) {
-      return Promise.reject(new Error(`${type.name}s cannot be directly fetched. The item may be paginated or not directly accessible.`))
-    }
-
-    if (mine && !this._getMineAllowed.has(type.name)) {
-      return Promise.reject(new Error(`${type.name}s cannot be filtered by the 'mine' parameter.`))
-    }
-
-    if (!mine && !id) {
-      return Promise.reject(new Error('Items must either specify an ID or the \'mine\' parameter.'))
-    }
-
-    let alreadyResolvedCount = 0
-    const alreadyResolved: InstanceType<K>[] = []
-    const idsToGet: string[] = []
-
-    if (typeof id === 'string') idsToGet.push(id)
-    else if (Array.isArray(id)) {
-      for (let i = 0; i < id.length; i++) {
-        const entry = id[i]
-
-        if (typeof entry === 'string') {
-          idsToGet.push(entry)
-        } else {
-          if (alreadyResolved.length < i + 1) alreadyResolved.length = id.length
-          alreadyResolved[i] = entry
-          alreadyResolvedCount++
-        }
-      }
-
-      // If all of the items are entities, what are we even doing here?
-      if (alreadyResolvedCount === id.length) {
-        return alreadyResolved as ItemReturns<T, K>
-      }
-    } else if (id) {
-      return id as ItemReturns<T, K>
-    }
-
-    const idString = idsToGet.join(',')
-    let preresolvedCacheString = alreadyResolved.length ? alreadyResolved.map(r => r.id).join(',') : ''
-
-    let cacheKey: string
-
-    if (this.youtube._shouldCache) {
-      cacheKey = `get://${type.endpoint}/${id ? idString : 'mine'}/${preresolvedCacheString}/${parts?.join(',')}`
-      const cached = Cache.get(cacheKey)
-      if (cached) return cached
-    }
-
-    const options: {
-      id?: string
-      mine?: boolean
-      fields: string
-      part: string
-      hl?: string
-    } = {
-      fields: encodeURIComponent(type.fields),
-      part: type === Comment ? 'snippet' : parts ? parts.join(',') : type.part
-    }
-
-    if (idString) options.id = idString
-    if (mine) options.mine = mine
-
-    if (type === VideoCategory) {
-      options.hl = this.youtube.language
-    }
-
-    const result: { items?: any[] } = await this.youtube._request.get(type.endpoint, {
-      params: options,
-      authorizationOptions: { [options.mine ? 'accessToken' : 'apiKey']: true }
-    })
-
-    if (!result.items?.length) {
-      return Promise.reject(new Error('Item not found'))
-    }
-
-    let endResult: ItemReturns<string | string[], ItemTypes>
-
-    if (!alreadyResolved.length) endResult = await Promise.all(result.items.map(async item => new (type)(this.youtube, await item, true)))
-    else {
-      for (const item of result.items) {
-        alreadyResolved[alreadyResolved.findIndex(value => value === undefined)] = new (type)(this.youtube, item, true) as InstanceType<K>
-      }
-
-      endResult = alreadyResolved
-    }
-
-    if (endResult.length === 1) endResult = endResult[0]
-    if (this.youtube._shouldCache) this.youtube._cache(cacheKey, endResult)
-
-    return endResult as ItemReturns<T, K>
-  }
-
-  /**
-   * 
-   * @param maxPerPage Leave undefined or set to < 1 to fetch the maximum allowed by the API for any given type.
-   * @param pages Number of pages to fetch from the API. Set to < 1 to fetch all of them. Defaults to 1.
-   * @param pageToken The page to start at (retrieved from the return value of a previous call to this function)
-   * 
-   * @returns An object containing the array of instantiated entities as well as possible next and previous page tokens.
-   */
-  public async getPaginatedItems<T extends PaginatedInstance = PaginatedInstance>
-  ({ type, mine = false, id, maxPerPage = 0, pages = 1, pageToken, subId, parts, ...otherFilters }: PaginatedItemOptions,
-    auth?: AuthorizationOptions): Promise<PaginatedResponse<T>> {
-
-    const name = PaginatedItemType[type] as keyof typeof PaginatedItemType
-
-    // These four types in the PaginatedItemTypes enum don't require any sort of identification parameter
-    if (!mine && !id &&
-        name !== 'VideoCategories' &&
-        name !== 'VideoAbuseReportReasons' &&
-        name !== 'Languages' &&
-        name !== 'Regions') {
-      return Promise.reject(new Error(`${name} must either specify an ID or the 'mine' parameter.`))
-    }
-
-    // These three types in the PaginatedItemTypes enum are the only to be filtered by the 'mine' parameter
-    if (mine && name !== 'Playlists' && name !== 'Subscriptions' && name !== 'ChannelSections') {
-      return Promise.reject(new Error(`${name} cannot be filtered by the 'mine' parameter.`))
-    }
-
-    let cacheKey: string
-
-    if (this.youtube._shouldCache) {
-      cacheKey = `getpage://${type}/${id ? id : 'mine'}/${subId}/${parts?.join(',')}/${maxPerPage >= 1 ? maxPerPage : 0}/${pages}/${pageToken}`
-      const cached = Cache.get(cacheKey)
-      if (cached) return cached
-    }
-
-    const options: PaginatedRequestParams = {
-      part: parts?.join(',')
-    }
-
-    let endpoint: string
-    let maxForEndpoint: number
-    let clazz: typeof Video | typeof Comment | typeof Playlist | typeof Subscription | typeof VideoCategory | typeof VideoAbuseReportReason | typeof Language |
-      typeof Region | typeof ChannelSection | typeof Caption
-    let commentType: 'video' | 'channel'
-
-    // MUST specify endpoint and clazz values, and most likely need a max as well
-    switch (type) {
-      case PaginatedItemType.PlaylistItems:
-        endpoint = 'playlistItems'
-        maxForEndpoint = 50
-        clazz = Video
-        options.playlistId = id
-
-        if (!options.part) options.part = 'snippet,contentDetails,status'
-        if (subId) options.videoId = subId
-        break
-
-      case PaginatedItemType.VideoComments:
-        commentType = 'video'
-        endpoint = 'commentThreads'
-        maxForEndpoint = 100
-        clazz = Comment
-        options[`${commentType}Id`] = id
-        if (!options.part) options.part = 'snippet,replies'
-        if (otherFilters.order) options.order = otherFilters.order
-        options.textFormat = 'plainText'
-        break
-
-      case PaginatedItemType.CommentReplies:
-        endpoint = 'comments'
-        maxForEndpoint = 100
-        clazz = Comment
-        if (!options.part) options.part = 'snippet'
-        options.parentId = id
-        break
-
-      case PaginatedItemType.Playlists:
-        endpoint = 'playlists'
-        clazz = Playlist
-        // falls through
-
-      case PaginatedItemType.Subscriptions:
-        if (!endpoint) endpoint = 'subscriptions'
-        if (!clazz) clazz = Subscription
-
-        maxForEndpoint = 50
-        // falls through
-
-      case PaginatedItemType.ChannelSections:
-        if (!endpoint) endpoint = 'channelSections'
-        if (!clazz) clazz = ChannelSection
-
-        if (mine) options.mine = mine; else options.channelId = id
-        break
-
-      case PaginatedItemType.VideoCategories:
-        endpoint = 'videoCategories'
-        clazz = VideoCategory
-        options.regionCode = this.youtube.region
-        // falls through
-
-      case PaginatedItemType.VideoAbuseReportReasons:
-        if (!endpoint) endpoint = 'videoAbuseReportReasons'
-        if (!clazz) clazz = VideoAbuseReportReason
-        // falls through
-
-      case PaginatedItemType.Languages:
-        if (!endpoint) endpoint = 'i18nLanguages'
-        if (!clazz) clazz = Language
-        // falls through
-
-      case PaginatedItemType.Regions:
-        if (!endpoint) endpoint = 'i18nRegions'
-        if (!clazz) clazz = Region
-        options.hl = this.youtube.language
-        break
-
-      case PaginatedItemType.Captions:
-        endpoint = 'captions'
-        clazz = Caption
-        options.videoId = id
-        break
-
-      default:
-        return Promise.reject(new TypeError('Unknown item type: ' + type))
-    }
-
-    if (!options.part) {
-      options.part = clazz.part
-    }
-
-    if (maxForEndpoint !== undefined) {
-      if (pages < 1 || maxPerPage < 1) options.maxResults = maxForEndpoint
-      else if (maxPerPage > maxForEndpoint) return Promise.reject(new Error(`Max per page must be ${maxForEndpoint} or below for ${endpoint}`))
-      else options.maxResults = maxPerPage
-    }
-
-    if (pages < 1) {
-      pages = Infinity
-    }
-
-    if (pageToken) options.pageToken = pageToken
-
-    const toReturn = await this.fetchPages(pages, endpoint, options, clazz, auth) as PaginatedResponse<T>
-
-    if (this.youtube._shouldCache) this.youtube._cache(cacheKey, toReturn)
-
-    return toReturn
-  }
-
-  /**
-   * @param clazz Most endpoints only return one type of entity, so set this to that entity.
-   * If endpoint is `search`, then leave undefined.
-   */
-  public async fetchPages<T extends PaginatedType = PaginatedType> (pages: number, endpoint: string, options:
-  { part: string; maxResults?: number; hl?: string; [key: string]: any }, clazz?: T,
-  auth?: AuthorizationOptions): Promise<PaginatedResponse<InstanceType<T>>> {
-
-    if (!clazz && endpoint !== 'search') {
-      return Promise.reject(new Error('Endpoints other than search must specify an entity class'))
-    }
-
-    const toReturn: PaginatedResponse<InstanceType<T>> = {
-      items: []
-    }
-
-    let pagesFetched = 0
-
-    while (true) {
-      const apiResponse = await this.youtube._request.get(endpoint, {
-        params: options,
-        authorizationOptions: auth ?? { [options.mine ? 'accessToken' : 'apiKey']: true }
-      })
-
-      if (!apiResponse.items?.length) {
-        if (apiResponse.prevPageToken) toReturn.prevPageToken = apiResponse.prevPageToken
-        break
-      }
-
-      pagesFetched++
-
-      for (const data of apiResponse.items) {
-        if (endpoint === 'search') {
-          if (data.id.videoId) {
-            toReturn.items.push(new Video(this.youtube, data) as InstanceType<T>)
-          } else if (data.id.channelId) {
-            toReturn.items.push(new Channel(this.youtube, data) as InstanceType<T>)
-          } else if (data.id.playlistId) {
-            toReturn.items.push(new Playlist(this.youtube, data) as InstanceType<T>)
-          }
-        } else if (data.kind === 'youtube#commentThread') {
-          toReturn.items.push(new Comment(this.youtube, data, true) as InstanceType<T>)
-        } else {
-          toReturn.items.push(new clazz(this.youtube, data, false) as InstanceType<T>)
-        }
-      }
-
-      if (pagesFetched >= pages || !apiResponse.nextPageToken) {
-        if (apiResponse.prevPageToken) toReturn.prevPageToken = apiResponse.prevPageToken
-        if (apiResponse.nextPageToken) toReturn.nextPageToken = apiResponse.nextPageToken
-
-        break
-      }
-
-      options.pageToken = apiResponse.nextPageToken
-    }
-
-    return toReturn
-  }
-}
+import { Cache } from '../util'
+import { ItemTypes, ItemReturns, PaginatedResponse, PaginatedItemType, PaginatedItemOptions,
+  PaginatedType, Resolvable, PaginatedInstance, PaginatedRequestParams, AuthorizationOptions } from '../types'
+import YouTube,
+{ Video, Channel, Playlist, Comment, VideoAbuseReportReason, Subscription, VideoCategory, Language, Region, ChannelSection, Caption, VideoRating } from '..'
+
+/**
+ * @ignore
+ */
+export class RetrievalService {
+  public readonly _getItemAllowedTypes = new Set([ Video, Channel, Playlist, Comment, Subscription, VideoCategory, ChannelSection, Caption ].map(c => c.name))
+  public readonly _getMineAllowed = new Set([ Playlist, Subscription, ChannelSection, Channel ].map(c => c.name))
+
+  constructor (private youtube: YouTube) {
+
+  }
+
+  public async getItem<T extends Resolvable<K> | Resolvable<K>[], K extends ItemTypes, M extends boolean = false>
+  (type: K, { mine, resolvableEntity }:
+  { mine?: M; resolvableEntity?: T }, parts?: string[]):
+  Promise<ItemReturns<T, K, M>> {
+
+    if (!this._getItemAllowedTypes.has(type.name)) {
+      return Promise.reject(new Error(`${type.name}s cannot be directly fetched. The item may be paginated or not directly accessible.`))
+    }
+
+    if (mine && !this._getMineAllowed.has(type.name)) {
+      return Promise.reject(new Error(`${type.name}s cannot be filtered by the 'mine' parameter.`))
+    }
+
+    if (!mine && !resolvableEntity) {
+      return Promise.reject(new Error('Items must either specify an ID or the \'mine\' parameter.'))
+    }
+
+    // Convert to array full of IDs and/or entity class instances
+    const resolvables: Resolvable<K>[] = mine ? [] : Array.isArray(resolvableEntity) ?
+      resolvableEntity :
+      [ resolvableEntity as Resolvable<K> ]
+
+    if (!mine && resolvables.length === 0) {
+      return Promise.reject(
+        new Error('The resolvableEntity parameter must include at least one item.')
+      )
+    }
+
+    // IDs
+    let resolvableStrings: string[]
+
+    // Instances of entity classes
+    let resolvedEntities: InstanceType<K>[]
+    let alreadyResolvedCount = 0
+
+    for (let i = 0; i < resolvables.length; i++) {
+      const entry = resolvables[i]
+
+      // An ID
+      if (typeof entry === 'string') {
+        const cachedEntity = this.youtube._shouldCache ? Cache.getItem(type, entry, parts) : undefined
+
+        if (!cachedEntity) {
+          if (!resolvableStrings) resolvableStrings = []
+          resolvableStrings.push(entry)
+        // An instance we have cached and can just return
+        } else {
+          if (!resolvedEntities) resolvedEntities = new Array(resolvables.length).fill(undefined)
+          resolvedEntities[i] = cachedEntity as InstanceType<K>
+          alreadyResolvedCount++
+        }
+      // An instance that we can just return
+      } else if (entry instanceof type) {
+        if (!resolvedEntities) resolvedEntities = new Array(resolvables.length).fill(undefined)
+        resolvedEntities[i] = entry
+        alreadyResolvedCount++
+      } else {
+        return Promise.reject(new TypeError(
+          'The resolvableEntity parameter must be a string, array, or proper entity class.'
+        ))
+      }
+    }
+
+    // If all of the items are instances, what are we even doing here?
+    if (!mine && alreadyResolvedCount === resolvables.length) {
+      return (resolvedEntities.length === 1 ?
+        resolvedEntities[0] :
+        resolvedEntities) as ItemReturns<T, K, M>
+    }
+
+    const idString = resolvableStrings?.join(',')
+
+    const options: {
+      id?: string
+      mine?: boolean
+      fields: string
+      part: string
+      hl?: string
+    } = {
+      fields: encodeURIComponent(type.fields),
+      part: type === Comment ? 'snippet' : parts ? parts.join(',') : type.part
+    }
+
+    if (idString) options.id = idString
+    if (mine) options.mine = mine
+
+    if (type === VideoCategory) {
+      options.hl = this.youtube.language
+    }
+
+    const result: { items?: any[] } = await this.youtube._request.get(type.endpoint, {
+      params: options,
+      authorizationOptions: { [options.mine ? 'accessToken' : 'apiKey']: true }
+    })
+
+    if (!result.items?.length) {
+      return Promise.reject(new Error('Item not found'))
+    }
+
+    // All resolvable entries are strings (IDs, URLs, and search queries)
+    if (!resolvedEntities) {
+      resolvedEntities = result.items.map((item, index) =>
+        this.transformItemToCachedEntity(type, item, resolvables[index] as string, parts))
+    // Otherwise there are some entity objects to include
+    } else {
+      let resultIndex = 0
+      // All undefined indices should coorelate with a string value in resolvables[]
+      // and a result from the API
+      resolvedEntities = resolvedEntities.map((entity, index) =>
+        entity ?? this.transformItemToCachedEntity(type, result.items[resultIndex++],
+          resolvables[index] as string, parts))
+
+      if (resultIndex < result.items.length - 1) {
+        return Promise.reject(new Error(`There are ${
+          result.items.length - resultIndex - 1} extra items in the response`))
+      }
+    }
+
+    return (resolvedEntities.length === 1 ?
+      resolvedEntities[0] :
+      resolvedEntities) as ItemReturns<T, K, M>
+  }
+
+  /**
+   * 
+   * @param maxPerPage Leave undefined or set to < 1 to fetch the maximum allowed by the API for any given type.
+   * @param pages Number of pages to fetch from the API. Set to < 1 to fetch all of them. Defaults to 1.
+   * @param pageToken The page to start at (retrieved from the return value of a previous call to this function)
+   * 
+   * @returns An object containing the array of instantiated entities as well as possible next and previous page tokens.
+   */
+  public async getPaginatedItems<T extends PaginatedInstance = PaginatedInstance>
+  ({ type, mine = false, id, maxPerPage = 0, pages = 1, pageToken, subId, parts, ...otherFilters }: PaginatedItemOptions,
+    auth?: AuthorizationOptions): Promise<PaginatedResponse<T>> {
+
+    const name = PaginatedItemType[type] as keyof typeof PaginatedItemType
+
+    // These four types in the PaginatedItemTypes enum don't require any sort of identification parameter
+    if (!mine && !id &&
+        name !== 'VideoCategories' &&
+        name !== 'VideoAbuseReportReasons' &&
+        name !== 'Languages' &&
+        name !== 'Regions') {
+      return Promise.reject(new Error(`${name} must either specify an ID or the 'mine' parameter.`))
+    }
+
+    // These three types in the PaginatedItemTypes enum are the only to be filtered by the 'mine' parameter
+    if (mine &&
+        name !== 'Playlists' && name !== 'Subscriptions' && name !== 'ChannelSections') {
+      return Promise.reject(new Error(`${name} cannot be filtered by the 'mine' parameter.`))
+    }
+
+    /* let cacheKey: string
+
+    if (this.youtube._shouldCache) {
+      cacheKey = `getpage://${type}/${id ? id : 'mine'}/${subId}/${parts?.join(',')}/${maxPerPage >= 1 ? maxPerPage : 0}/${pages}/${pageToken}`
+      const cached = Cache.get(cacheKey)
+      if (cached) return cached
+    } */
+
+    const options: PaginatedRequestParams = {
+      part: parts?.join(',')
+    }
+
+    let endpoint: string
+    let maxForEndpoint: number
+    let clazz: typeof Video | typeof Comment | typeof Playlist | typeof Subscription |
+      typeof VideoCategory | typeof VideoAbuseReportReason | typeof Language |
+      typeof Region | typeof ChannelSection | typeof Caption | typeof VideoRating
+    let commentType: 'video' | 'channel'
+
+    // MUST specify endpoint and clazz values, and most likely need a max as well
+    switch (type) {
+      case PaginatedItemType.PlaylistItems:
+        endpoint = 'playlistItems'
+        maxForEndpoint = 50
+        clazz = Video
+        options.playlistId = id
+
+        if (!options.part) options.part = 'snippet,contentDetails,status'
+        if (subId) options.videoId = subId
+        break
+
+      case PaginatedItemType.VideoComments:
+        commentType = 'video'
+        endpoint = 'commentThreads'
+        maxForEndpoint = 100
+        clazz = Comment
+        options[`${commentType}Id`] = id
+        options.textFormat = 'plainText'
+
+        if (!options.part) options.part = 'snippet,replies'
+        if (otherFilters.order) options.order = otherFilters.order
+        break
+
+      case PaginatedItemType.CommentReplies:
+        endpoint = 'comments'
+        maxForEndpoint = 100
+        clazz = Comment
+        if (!options.part) options.part = 'snippet'
+        options.parentId = id
+        break
+
+      case PaginatedItemType.Captions:
+        endpoint = 'captions'
+        clazz = Caption
+        options.videoId = id
+        break
+
+      case PaginatedItemType.Playlists:
+        endpoint = 'playlists'
+        clazz = Playlist
+        // falls through
+      case PaginatedItemType.Subscriptions:
+        if (!endpoint) endpoint = 'subscriptions'
+        if (!clazz) clazz = Subscription
+        if (subId) options.forChannelId = subId
+
+        maxForEndpoint = 50
+        // falls through
+      case PaginatedItemType.ChannelSections:
+        if (!endpoint) endpoint = 'channelSections'
+        if (!clazz) clazz = ChannelSection
+
+        if (mine) options.mine = mine
+        else options.channelId = id
+        break
+
+      case PaginatedItemType.VideoCategories:
+        endpoint = 'videoCategories'
+        clazz = VideoCategory
+        options.regionCode = this.youtube.region
+        break
+
+      case PaginatedItemType.VideoAbuseReportReasons:
+        endpoint = 'videoAbuseReportReasons'
+        clazz = VideoAbuseReportReason
+        options.hl = this.youtube.language
+        // falls through
+      case PaginatedItemType.Languages:
+        if (!endpoint) endpoint = 'i18nLanguages'
+        if (!clazz) clazz = Language
+        // falls through
+      case PaginatedItemType.Regions:
+        if (!endpoint) endpoint = 'i18nRegions'
+        if (!clazz) clazz = Region
+        break
+
+      case PaginatedItemType.VideoRatings:
+        endpoint = 'videos/getRating'
+        clazz = VideoRating
+        options.id = id
+        break
+
+      default:
+        return Promise.reject(new TypeError('Unknown item type: ' + type))
+    }
+
+    if (!clazz.part) delete options.part
+    else if (!options.part) options.part = clazz.part
+
+    if (pages < 1) pages = Infinity
+    if (pageToken) options.pageToken = pageToken
+
+    if (maxForEndpoint !== undefined) {
+      if (pages === Infinity || maxPerPage < 1) options.maxResults = maxForEndpoint
+      else if (maxPerPage <= maxForEndpoint) options.maxResults = maxPerPage
+      else {
+        return Promise.reject(
+          new Error(`Max per page must be ${maxForEndpoint} or below for ${endpoint}`))
+      }
+    }
+
+    // Caching handled here
+    return this.getPages(
+      pages, endpoint, options, clazz, auth, parts) as Promise<PaginatedResponse<T>>
+  }
+
+  /**
+   * Caching handled here
+   * @param clazz Most endpoints only return one type of entity, so set this to that entity.
+   * If endpoint is `search`, then leave undefined.
+   */
+  public async getPages<T extends PaginatedType = PaginatedType> (
+    pages: number, endpoint: string, options: PaginatedRequestParams, clazz?: T,
+    auth?: AuthorizationOptions, parts?: string[]):
+  Promise<PaginatedResponse<InstanceType<T>>> {
+
+    if (!clazz && endpoint !== 'search') {
+      return Promise.reject(new Error('Endpoints other than search must specify an entity class'))
+    }
+
+    let toReturn: PaginatedResponse<InstanceType<T>> = {
+      items: []
+    }
+
+    const cachedPages = this.youtube._shouldCache ?
+      Cache.getPages<InstanceType<T>>(endpoint, options, auth, parts, clazz) :
+      undefined
+
+    let pagesFetched = 0
+
+
+    while (true) {
+      let page: PaginatedResponse<any>
+
+      if (this.youtube._shouldCache) {
+        page = cachedPages?.[pagesFetched]
+
+        // We have a cached page, use that
+        if (page) {
+          toReturn.items = toReturn.items.concat(page.items)
+          if (page.prevPageToken) toReturn.prevPageToken = page.prevPageToken
+          if (page.nextPageToken) toReturn.nextPageToken = page.nextPageToken
+          if (++pagesFetched >= pages || !page.nextPageToken) break
+          options.pageToken = toReturn.nextPageToken
+          continue
+        }
+      }
+
+      // No cached page, request one from the API
+      page = await this.youtube._request.get(endpoint, {
+        params: options,
+        authorizationOptions: auth ?? { [options.mine ? 'accessToken' : 'apiKey']: true } })
+
+      // No more items found, return
+      if (!page.items?.length) {
+        if (page.prevPageToken) toReturn.prevPageToken = page.prevPageToken
+        break
+      }
+
+      const instances: InstanceType<T>[] = []
+
+      for (const data of page.items) {
+        if (endpoint === 'search') {
+          if (data.id.videoId) {
+            instances.push(new Video(this.youtube, data) as InstanceType<T>)
+          } else if (data.id.channelId) {
+            instances.push(new Channel(this.youtube, data) as InstanceType<T>)
+          } else if (data.id.playlistId) {
+            instances.push(new Playlist(this.youtube, data) as InstanceType<T>)
+          }
+        } else if (data.kind === 'youtube#commentThread') {
+          instances.push(new Comment(this.youtube, data, true) as InstanceType<T>)
+        } else {
+          instances.push(new clazz(this.youtube, data, false) as InstanceType<T>)
+        }
+      }
+
+      toReturn.items = toReturn.items.concat(instances)
+
+      const toCache: PaginatedResponse<InstanceType<T>> = {
+        items: instances
+      }
+
+      if (page.prevPageToken) toCache.prevPageToken = page.prevPageToken
+      if (page.nextPageToken) toCache.nextPageToken = page.nextPageToken
+
+      if (this.youtube._shouldCache) {
+        this.youtube._cachePage(
+          endpoint, pagesFetched, options, auth, parts, clazz, toCache)
+      }
+
+      if (++pagesFetched >= pages || !page.nextPageToken) {
+        if (page.prevPageToken) toReturn.prevPageToken = page.prevPageToken
+        if (page.nextPageToken) toReturn.nextPageToken = page.nextPageToken
+
+        break
+      }
+
+      options.pageToken = page.nextPageToken
+    }
+
+    return toReturn
+  }
+
+  private transformItemToCachedEntity<K extends ItemTypes>
+  (type: K, item: any, cacheString: string, parts?: string[]):
+  InstanceType<K> {
+    const entity = new (type)(this.youtube, item, true) as InstanceType<K>
+
+    if (this.youtube._shouldCache) {
+      this.youtube._cacheItem(type, cacheString, entity, parts)
+    }
+
+    return entity
+  }
+}
diff --git a/src/services/search-service.ts b/src/services/search-service.ts
index 7760a7771..02eb27791 100644
--- a/src/services/search-service.ts
+++ b/src/services/search-service.ts
@@ -1,4 +1,3 @@
-import { Cache } from '../util'
 import YouTube, { Video, Channel, Playlist, InternalSearchOptions, SearchType, PaginatedResponse, SearchFilters, VideoCategory } from '..'
 
 /**
@@ -16,11 +15,6 @@ export class SearchService {
 
     const type = types.map(t => t.name.toLowerCase()).join(',')
 
-    if (this.youtube._shouldCache) {
-      const cached = Cache.get(`search://${type}/"${searchTerm}"/${pages}/${maxPerPage}/${pageToken}/${JSON.stringify(otherFilters)}`)
-      if (cached) return cached
-    }
-
     if (maxPerPage < 1) {
       return Promise.reject(new Error('Max per page must be above 0'))
     }
@@ -60,11 +54,11 @@ export class SearchService {
     const searchFilters = otherFilters as unknown as SearchFilters<T>
 
     if ('channel' in searchFilters) {
-      const channel = await this.youtube._resolutionService.resolve(searchFilters.channel, Channel)
+      const channel = await this.youtube._services.resolution.resolve(searchFilters.channel, Channel)
       options.channelId = typeof channel === 'string' ? channel : channel.id
     }
     if ('videoCategory' in searchFilters) {
-      const videoCategory = await this.youtube._resolutionService.resolve(searchFilters.videoCategory, VideoCategory)
+      const videoCategory = await this.youtube._services.resolution.resolve(searchFilters.videoCategory, VideoCategory)
       options.videoCategoryId = typeof videoCategory === 'string' ? videoCategory : videoCategory.id
     }
     if ('eventType' in searchFilters) options.eventType = searchFilters.eventType
@@ -75,12 +69,7 @@ export class SearchService {
     if ('order' in searchFilters) options.order = searchFilters.order
     if ('videoEmbeddable' in searchFilters) options.videoEmbeddable = 'true'
 
-    const toReturn = await this.youtube._genericService.fetchPages<T>(pages, 'search', options)
-
-    if (this.youtube._shouldCache && this.youtube._cacheSearches) {
-      this.youtube._cache(`search://${type}/"${searchTerm}"/${pages}/${maxPerPage}/${pageToken}/${JSON.stringify(otherFilters)}`, toReturn)
-    }
-
-    return toReturn
+    // Caching handled here
+    return this.youtube._services.retrieval.getPages<T>(pages, 'search', options)
   }
 }
diff --git a/src/services/subscription-service.ts b/src/services/subscription-service.ts
deleted file mode 100644
index 0ec20cba5..000000000
--- a/src/services/subscription-service.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { Cache } from '../util'
-import { SubscriptionParts } from '../types/Parts'
-import YouTube, { AuthorizationOptions, Subscription } from '..'
-
-/**
- * @ignore
- */
-export class SubscriptionService {
-  constructor (private youtube: YouTube) {}
-
-  public async getSubscriptionByChannels (subscriberId: string, channelId: string,
-    parts?: SubscriptionParts, auth?: AuthorizationOptions): Promise<Subscription> {
-
-    if (this.youtube._shouldCache) {
-      const cached = Cache.get(`sub_by_channels://"${subscriberId}"/"${channelId}"`)
-      if (cached) return cached
-    }
-
-    const options: {
-      part: string
-      forChannelId: string
-      channelId: string
-      maxResults: number
-    } = {
-      part: parts ? parts.join(',') : 'snippet,contentDetails,subscriberSnippet',
-      forChannelId: channelId,
-      channelId: subscriberId,
-      maxResults: 1
-    }
-
-    const results = await this.youtube._request.get('subscriptions',
-      { params: options, authorizationOptions: auth ?? { apiKey: true } })
-
-    if (!results.items?.length) {
-      return Promise.reject(new Error('Subscription not found'))
-    }
-
-    const toReturn = new Subscription(this.youtube, results.items[0])
-
-    if (this.youtube._shouldCache && this.youtube._cacheSearches) {
-      this.youtube._cache(`sub_by_channels://"${subscriberId}"/"${channelId}"`, toReturn)
-    }
-
-    return toReturn
-  }
-}
diff --git a/src/types/Cache.ts b/src/types/Cache.ts
new file mode 100644
index 000000000..e09f9f990
--- /dev/null
+++ b/src/types/Cache.ts
@@ -0,0 +1,10 @@
+/**
+ * @ignore
+ * v = Value  
+ * t = Time to live  
+ * p = Parts string (sorted!)
+ */
+export type CacheItem<T = any> = {
+  v: T
+  t: number
+}
diff --git a/src/types/GetItem.ts b/src/types/GetItem.ts
index 394dce9c5..de3cbd76b 100644
--- a/src/types/GetItem.ts
+++ b/src/types/GetItem.ts
@@ -1,7 +1,11 @@
-import { Video, Channel, Playlist, Comment, Subscription, VideoCategory, ChannelSection, Caption } from '..'
+import { Video, Channel, Playlist, Comment, Subscription, VideoCategory, ChannelSection, Caption, VideoRating } from '..'
 
-export const GETTABLE_CLASSES = [ Video, Channel, Playlist, Comment, Subscription, VideoCategory, ChannelSection, Caption ]
+export const GETTABLE_CLASSES =
+  [ Video, Channel, Playlist, Comment, Subscription,
+    VideoCategory, ChannelSection, Caption, VideoRating ]
 
 export type ItemTypes = typeof GETTABLE_CLASSES[number]
 
-export type ItemReturns<T extends any | any[], K extends ItemTypes> = T extends any[] ? InstanceType<K>[] : InstanceType<K>
+export type ItemReturns<T extends any | any[], K extends ItemTypes, M extends boolean> =
+    M extends true ? InstanceType<K> :
+    T extends any[] ? InstanceType<K>[] : InstanceType<K>
diff --git a/src/types/GetPaginatedItems.ts b/src/types/GetPaginatedItems.ts
index a69763100..72c3a3346 100644
--- a/src/types/GetPaginatedItems.ts
+++ b/src/types/GetPaginatedItems.ts
@@ -1,8 +1,9 @@
-import { Video, Channel, Comment, Playlist, Subscription, VideoCategory, VideoAbuseReportReason, Language, Region, ChannelSection, Caption } from '..'
-import { ChannelResolvable, VideoCategoryResolvable } from './Resolvable'
+import { Video, Channel, Comment, Playlist, Subscription, VideoCategory, VideoAbuseReportReason, Language, Region, ChannelSection, Caption, VideoRating } from '..'
+import { ChannelResolvable, VideoCategoryResolvable } from './Resolutions'
 
 const PAGINATED_CLASSES = [
-  VideoCategory, VideoAbuseReportReason, Language, Region, Video, Comment, Caption, Playlist, Subscription, ChannelSection, Channel
+  VideoCategory, VideoAbuseReportReason, Language, Region, Video, Comment, Caption,
+  Playlist, Subscription, ChannelSection, Channel, VideoRating
 ]
 
 /**
@@ -13,6 +14,7 @@ export enum PaginatedItemType {
   VideoAbuseReportReasons,
   Languages,
   Regions,
+  VideoRatings,
   PlaylistItems,
   VideoComments,
   CommentReplies,
@@ -48,11 +50,13 @@ export type PaginatedItemOptions = {
 export type PaginatedRequestParams = {
   part: string
   maxResults?: number
+  id?: string
   videoId?: string
   parentId?: string
   textFormat?: string
   playlistId?: string
   channelId?: string
+  forChannelId?: string
   regionCode?: string
   pageToken?: string
   mine?: boolean
diff --git a/src/types/Resolvable.ts b/src/types/Resolutions.ts
similarity index 86%
rename from src/types/Resolvable.ts
rename to src/types/Resolutions.ts
index ed598c34d..f061054ff 100644
--- a/src/types/Resolvable.ts
+++ b/src/types/Resolutions.ts
@@ -1,4 +1,5 @@
-import { Channel, Playlist, Video, VideoCategory, Comment, PaginatedType, Subscription } from '..'
+import { Channel, Playlist, Video, VideoCategory, Comment, PaginatedType,
+  Subscription, CacheItem } from '..'
 
 const RESOLVABLE_CLASSES = [
   Video, Playlist, Channel, VideoCategory, Comment, Subscription
@@ -6,6 +7,9 @@ const RESOLVABLE_CLASSES = [
 
 export type Resolvable<T extends PaginatedType> = string | InstanceType<T>
 
+export type ResolutionMap<T extends ResolvableClass = ResolvableClass> =
+  Map<T, Map<string, CacheItem<Resolvable<T>>>>
+
 /**
  * @ignore
  */
diff --git a/src/types/index.ts b/src/types/index.ts
index 199cd9bf4..9881b6bdf 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -8,4 +8,5 @@ export * from './BrandingSettings'
 export * from './ChannelSectionType'
 export * from './Parts'
 export * from './Util'
-export * from './Resolvable'
+export * from './Resolutions'
+export * from './Cache'
diff --git a/src/util/arrays.ts b/src/util/arrays.ts
new file mode 100644
index 000000000..f1bde3c47
--- /dev/null
+++ b/src/util/arrays.ts
@@ -0,0 +1,21 @@
+export function findArrayIndexFrom<T>
+(predicate: (element: T) => boolean, array: T[], startFrom: number): number {
+  for (let i = startFrom; i < array.length; i++) {
+    if (predicate(array[i])) {
+      return i
+    }
+  }
+
+  return -1
+}
+
+export function findArrayFrom<T>
+(predicate: (element: T) => boolean, array: T[], startFrom: number): [number, T] {
+  for (let i = startFrom; i < array.length; i++) {
+    if (predicate(array[i])) {
+      return [i, array[i]]
+    }
+  }
+
+  return undefined
+}
diff --git a/src/util/cache.ts b/src/util/cache.ts
index 5ce829ac6..0988615b2 100644
--- a/src/util/cache.ts
+++ b/src/util/cache.ts
@@ -1,45 +1,282 @@
+import { AuthorizationOptions, CacheItem, ItemTypes, PaginatedInstance,
+  PaginatedRequestParams, PaginatedResponse, PaginatedType, ResolutionMap,
+  Resolvable, ResolvableClass } from '..'
+import { findArrayFrom } from '.'
+
 /**
  * @ignore
  */
 export class Cache {
-  private static map: Map<string, CacheItem> = new Map()
+  /**
+  * Map of resolutions separated by type.
+  */
+  private static resolutionMap: ResolutionMap = new Map()
+
+  /** 
+   * Map of items that are separated by which parts were requested from the API and then
+   * their ID/URL/search query.
+   */
+  private static itemMap:
+  Map<string, Map<string, CacheItem<InstanceType<ItemTypes>>>> = new Map()
+
+  /** 
+   * Map of arrays of pages of items that are separated by which parts were requested
+   * from the API and then a cache key generated from the request options.
+   */
+  private static pagesMap:
+    Map<string, Map<string, CacheItem<PaginatedResponse<PaginatedInstance>>[]>> = new Map()
 
-  public static set (key: string, value: any, ttl: number) {
-    Cache.map.set(key, { v: value, t: ttl })
+  public static setResolution<T extends ResolvableClass = ResolvableClass>
+  (type: T, input: string, value: Resolvable<T>, ttl: number) {
+    const cachedWithSameType = Cache.resolutionMap.get(type) ??
+      Cache.resolutionMap.set(type, new Map()).get(type)
+    cachedWithSameType.set(input, { v: value, t: ttl })
   }
 
-  public static get (key: string): any {
-    const item = Cache.map.get(key)
+  public static getResolution<T extends ResolvableClass = ResolvableClass>
+  (type: T, input: string): Resolvable<T> {
+    const cachedWithSameType = Cache.resolutionMap.get(type) as
+      Map<string, CacheItem<Resolvable<T>>>
+
+    if (!cachedWithSameType) return undefined
+
+    const item = cachedWithSameType.get(input)
 
     if (!item || (item.t > 0 && new Date().getTime() >= item.t)) {
-      Cache._delete(key)
+      Cache._deleteResolution(type, input)
       return undefined
     }
 
     return item.v
   }
 
+  public static setItem (type: ItemTypes, name: string, value: InstanceType<ItemTypes>,
+    ttl: number, parts?: string[]) {
+    const key = `${type.name.toLowerCase()}/${name}` // The item key string
+    const part = parts ? parts.sort().join(',') : type.part // The parts key string
+    const cachedWithSameParts = Cache.itemMap.get(part) ?? // The parts map
+      Cache.itemMap.set(part, new Map()).get(part)
+
+    cachedWithSameParts.set(key, { v: value, t: ttl })
+  }
+
+  public static setItems (type: ItemTypes, names: string[],
+    values: InstanceType<ItemTypes>[], ttl: number, parts?: string[]) {
+    if (names.length !== values.length) {
+      throw new Error(
+        'The number of cache keys must be equivalent to the number of items to cache'
+      )
+    }
+
+    for (let i = 0; i < names.length; i++) {
+      Cache.setItem(type, names[i], values[i], ttl, parts)
+    }
+  }
+
+  public static getItem<T extends ItemTypes = ItemTypes> (type: T, name: string,
+    parts?: string[]): InstanceType<T> | undefined {
+    const part = parts ? parts.sort().join(',') : type.part
+    const key = `${type.name.toLowerCase()}/${name}`
+
+    // Search for an item that has the same or more parts than we need
+    const item = Cache.findCachedItemWithParts(Cache.itemMap, part, key)
+
+    if (!item) return undefined
+    if (item.t > 0 && new Date().getTime() >= item.t) {
+      Cache._deleteItem(key, part)
+      return undefined
+    }
+
+    return item.v as InstanceType<T>
+  }
+
+  public static setPage (endpoint: string, page: number,
+    options: PaginatedRequestParams, auth: AuthorizationOptions | undefined,
+    parts: string[] | undefined, type: PaginatedType | undefined,
+    value: PaginatedResponse<PaginatedInstance>, ttl: number) {
+
+    const part = parts ? parts.sort().join(',') : type?.part ?? 'default'
+    const key = `${endpoint}/${
+      JSON.stringify({ ...options, pageToken: undefined, part: undefined })}/${
+      auth?.accessToken ?? false}/${auth?.apiKey ?? false}`
+
+    const cachedWithSameParts = Cache.pagesMap.get(part) ??
+      Cache.pagesMap.set(part, new Map()).get(part)
+    const toCache = cachedWithSameParts.get(key) ?? []
+
+    if (page > toCache.length - 1) toCache.length = page + 1
+    toCache[page] = { v: value, t: ttl }
+
+    cachedWithSameParts.set(key, toCache)
+  }
+
+  public static getPages<T extends PaginatedInstance = PaginatedInstance> (
+    endpoint: string, options: PaginatedRequestParams,
+    auth?: AuthorizationOptions, parts?: string[], type?: PaginatedType):
+  PaginatedResponse<T>[] | undefined {
+    const key = `${endpoint}/${
+      JSON.stringify({ ...options, pageToken: undefined, part: undefined })}/${
+      auth?.accessToken ?? false}/${auth?.apiKey ?? false}`
+    const part = parts ? parts.sort().join(',') : type?.part ?? 'default'
+
+    // Search for a page that has the same or more parts than we need
+    const pages = Cache.findCachedItemWithParts(Cache.pagesMap, part, key)
+
+    if (!pages) return undefined
+
+    const toReturn: PaginatedResponse<T>[] = new Array(pages.length)
+
+    for (let page = 0; page < pages.length; page++) {
+      const item = pages[page]
+
+      if (!item) continue
+      if (item.t > 0 && new Date().getTime() >= item.t) {
+        Cache._deletePage(endpoint, page, options, auth, parts, type)
+        continue
+      }
+
+      toReturn[page] = item.v as PaginatedResponse<T>
+    }
+
+    return toReturn
+  }
+
+  private static findCachedItemWithParts<T> (cache: Map<string, Map<string, T>>,
+    part: string, key: string): T {
+    let cachedWithSameParts = cache.get(part) // A map with matching parts
+    let item = cachedWithSameParts?.get(key) // A matching page with our parts
+
+    if (item) return item
+
+    let currentIndex = 0
+    const partKeys = Array.from(cache.keys())
+
+    while (!item) {
+      // Find a page that contains our data
+      const matchingPart = findArrayFrom(p => p.includes(part),
+        partKeys, currentIndex)
+      if (!matchingPart) break
+
+      currentIndex = matchingPart[0] + 1 // Increment index
+      cachedWithSameParts = cache.get(matchingPart[1])
+      item = cachedWithSameParts?.get(key)
+    }
+
+    return item
+  }
+
   public static checkTTLs () {
     const time = new Date().getTime()
 
-    for (const [ name, value ] of Cache.map.entries()) {
-      const timeToDelete = value.t
+    for (const [ part, cache ] of Cache.itemMap.entries()) {
+      for (const [ key, item ] of cache.entries()) {
+        const timeToDelete = item.t
 
-      if (timeToDelete > 0 && time >= timeToDelete) {
-        Cache.map.delete(name)
+        if (timeToDelete > 0 && time >= timeToDelete) {
+          Cache._deleteItem(key, part)
+        }
+      }
+    }
+
+    for (const [ type, cache ] of Cache.resolutionMap.entries()) {
+      for (const [ key, item ] of cache.entries()) {
+        const timeToDelete = item.t
+
+        if (timeToDelete > 0 && time >= timeToDelete) {
+          Cache._deleteResolution(type, key)
+        }
+      }
+    }
+
+    for (const [ part, cache ] of Cache.pagesMap.entries()) {
+      for (let [ key, pages ] of cache.entries()) {
+        for (let page = 0; page < pages.length; page++) {
+          if (!pages[page]) continue
+
+          const timeToDelete = pages[page].t
+          if (timeToDelete > 0 && time >= timeToDelete) {
+            pages = Cache._deletePageByKey(part, key, page)
+            page--
+          }
+        }
       }
     }
   }
 
-  public static _delete (name: string) {
-    Cache.map.delete(name)
+  public static setTTLs (ttl: number) {
+    for (const cache of Cache.itemMap.values()) {
+      for (let [ key, item ] of cache.entries()) {
+        cache.set(key, { ...item, t: ttl })
+      }
+    }
+
+    for (const cache of Cache.resolutionMap.values()) {
+      for (let [ key, item ] of cache.entries()) {
+        cache.set(key, { ...item, t: ttl })
+      }
+    }
+
+    for (const cache of Cache.pagesMap.values()) {
+      for (let [ key, pages ] of cache.entries()) {
+        for (let page = 0; page < pages.length; page++) {
+          if (!pages[page]) continue
+
+          pages[page].t = ttl
+          cache.set(key, pages)
+        }
+      }
+    }
   }
-}
 
-/**
- * @ignore
- */
-type CacheItem = {
-  v: any
-  t: number
+  public static _deleteItem (key: string, parts?: string) {
+    const cachedWithSameParts = Cache.itemMap.get(parts ?? '')
+    const cacheItem = cachedWithSameParts?.get(key)
+
+    cachedWithSameParts?.delete(key)
+    return cacheItem
+  }
+
+  public static _deleteResolution (type: ResolvableClass, input: string) {
+    const cachedWithSameType = Cache.resolutionMap.get(type)
+    const cacheItem = cachedWithSameType?.get(input)
+
+    cachedWithSameType?.delete(input)
+    return cacheItem
+  }
+
+  /**
+   * @returns Pages left in the key
+   */
+  public static _deletePageByKey (parts: string, key: string, page: number) {
+    const cachedItems = Cache.pagesMap.get(parts)
+    const pages = cachedItems?.get(key)
+
+    if (!pages) return
+    if (page > pages.length - 1) return pages
+
+    pages.splice(page, 1)
+
+    if (pages.length === 0) {
+      cachedItems.delete(key)
+    } else {
+      cachedItems.set(key, pages)
+    }
+
+    return pages
+  }
+
+  /**
+   * @returns Pages left in the key
+   */
+  public static _deletePage (endpoint: string, page: number,
+    options: PaginatedRequestParams, auth?: AuthorizationOptions, parts?: string[],
+    type?: PaginatedType) {
+
+    const part = parts ? parts.sort().join(',') : type?.part ?? 'default'
+    const key = `${endpoint}/${
+      JSON.stringify({ ...options, pageToken: undefined, part: undefined })}/${
+      auth?.accessToken ?? false}/${auth?.apiKey ?? false}`
+
+    return Cache._deletePageByKey(part, key, page)
+  }
 }
diff --git a/src/util/index.ts b/src/util/index.ts
index 27c5f8ec8..aab068847 100644
--- a/src/util/index.ts
+++ b/src/util/index.ts
@@ -1,3 +1,4 @@
 export * from './parser'
 export * from './request'
 export * from './cache'
+export * from './arrays'
diff --git a/test/cache.spec.ts b/test/cache.spec.ts
index 0b3b12d16..e32f7952f 100644
--- a/test/cache.spec.ts
+++ b/test/cache.spec.ts
@@ -1,8 +1,9 @@
 import 'mocha'
 import './setup-instance'
 
+import { setTimeout } from 'timers/promises'
 import { Cache } from '../src/util/cache'
-import { YouTube } from '../src'
+import { VideoRating, YouTube } from '../src'
 import { expect } from 'chai'
 
 const apiKey = process.env.YOUTUBE_API_KEY
@@ -17,7 +18,7 @@ describe('Caching', () => {
 
     await youtube.getVideo('dQw4w9WgXcQ')
 
-    const video = youtube.getVideo('dQw4w9WgXcQ')
+    const video = youtube.getVideo('dQw4w9WgXcQ', [ 'contentDetails' ])
     const time = new Date().getTime()
 
     await video
@@ -36,60 +37,54 @@ describe('Caching', () => {
   })
 
   it('should not use expired items', async () => {
+    Cache.setTTLs(1) // for clearing previous test cache
+
     const youtube = new YouTube(apiKey, undefined, { cacheTTL: 0.001, cacheCheckInterval: 0.009 })
-    await youtube.getVideo('dQw4w9WgXcQ')
+    await setTimeout(20) // clearing previous test cache
 
-    const time = new Date().getTime()
-    const video = youtube.getVideo('dQw4w9WgXcQ')
+    await youtube.getVideo('dQw4w9WgXcQ')
+    await setTimeout(20) // give enough time to clear cache
 
-    await video
+    let time = new Date().getTime()
+    const video = await youtube.getVideo('dQw4w9WgXcQ')
 
     expect(new Date().getTime() - time).to.be.greaterThan(30)
-  })
 
-  it('should delete items successfully', () => {
-    Cache.set('test', 'value', 0)
-    Cache._delete('test')
+    await video.fetchComments()
+    await setTimeout(20)
+
+    time = new Date().getTime()
+    const comments = video.fetchComments()
+
+    await comments
 
-    expect(Cache.get('test')).to.equal(undefined)
+    expect(new Date().getTime() - time).to.be.greaterThan(30)
   })
 
+  const testRating = new VideoRating(new YouTube('test'),
+    { videoId: 'test', rating: 'like' })
+
   it('should ignore items with a ttl <= 0', () => {
-    Cache.set('test', 'value', 0)
+    Cache.setItem(VideoRating, 'test', testRating, 0)
     Cache.checkTTLs()
 
-    expect(Cache.get('test')).to.equal('value')
+    expect(Cache.getItem(VideoRating, 'test')).to.equal(testRating)
 
-    Cache._delete('test')
+    Cache._deleteItem('videorating/test')
   })
 
   it('should delete expired items', () => {
-    Cache.set('test', 'value', 1)
+    Cache.setItem(VideoRating, 'test', testRating, 1)
     Cache.checkTTLs()
 
-    expect(Cache.get('test')).to.equal(undefined)
-  })
-
-  it('should not cache if _shouldCalche is false', () => {
-    const youtube = new YouTube(apiKey, undefined, { cache: false })
-    youtube._cache('test', 'value')
-
-    expect(Cache.get('test')).to.equal(undefined)
-  })
-
-  it('should cache if _shouldCache is true', () => {
-    const youtube = new YouTube(apiKey, undefined, { cache: true, cacheTTL: 60 })
-    youtube._cache('test', 'value')
-
-    expect(Cache.get('test')).to.equal('value')
-    Cache._delete('test')
+    expect(Cache.getItem(VideoRating, 'test')).to.equal(undefined)
   })
 
   it('should cache forever if cacheTTL is <= 0', () => {
     const youtube = new YouTube(apiKey, undefined, { cache: true, cacheTTL: 0 })
-    youtube._cache('test', 'value')
+    youtube._cacheItem(VideoRating, 'test', testRating)
 
-    expect(Cache.get('test')).to.equal('value')
-    Cache._delete('test')
+    expect(Cache.getItem(VideoRating, 'test')).to.equal(testRating)
+    expect(Cache._deleteItem('videorating/test')?.v).to.equal(testRating)
   })
 })
diff --git a/test/channel.spec.ts b/test/channel.spec.ts
index eee65908c..140dc9732 100644
--- a/test/channel.spec.ts
+++ b/test/channel.spec.ts
@@ -1,5 +1,5 @@
 import 'mocha'
-import { Channel, Playlist, Subscription, ChannelSection } from '../src'
+import { Channel, Playlist, Subscription, ChannelSection, PaginatedResponse } from '../src'
 import { youtube } from './setup-instance'
 import { expect } from 'chai'
 
@@ -29,8 +29,9 @@ describe('Channels', () => {
     expect(await youtube.getChannel('https://www.youtube.com/channel/UCBR8-60-B28hp2BmDPdntcQ', [ 'id' ])).to.be.an.instanceOf(Channel)
   })
 
-  it('shouldn\'t work with proper usernames', async () => {
-    expect(await youtube.getChannel('@brandonbothell', [ 'id' ]).catch(e => e.message)).to.equal('Channel not found')
+  it('should work with proper usernames', async () => {
+    expect(await youtube.getChannel('@brandonbothell', [ 'id' ]))
+      .to.be.an.instanceOf(Channel)
   })
 
   it('should work with single searching', async () => {
@@ -49,17 +50,33 @@ describe('Channels', () => {
 
   it('should work with fetching pages of playlists', async () => {
     const channel = await youtube.getChannel('UCBR8-60-B28hp2BmDPdntcQ', [ 'id' ])
-    expect((await channel.fetchPlaylists({ pages: 2 }, [ 'id' ])).items.length).to.equal(100)
+    expect((await channel.fetchPlaylists({ pages: 2 }, [ 'id' ]))
+      .items.length).to.equal(100)
   })
 
   it('should work with fetching playlists', async () => {
     const channel = await youtube.getChannel('UC6mi9rp7vRYninucP61qOjg', [ 'id' ])
-    expect((await channel.fetchPlaylists(undefined, [ 'id' ])).items[0]).to.be.an.instanceOf(Playlist)
+    expect((await channel.fetchPlaylists(undefined, [ 'id', 'contentDetails' ]))
+      .items[0]).to.be.an.instanceOf(Playlist)
+  })
+
+  it('should work with caching playlists', async () => {
+    const channel = await youtube.getChannel('UC6mi9rp7vRYninucP61qOjg', [ 'id' ])
+    let playlist: Playlist | Promise<PaginatedResponse<Playlist>> =
+      channel.fetchPlaylists(undefined, [ 'contentDetails' ])
+    const time = new Date().getTime()
+
+    playlist = (await playlist).items[0]
+
+    expect(new Date().getTime() - time).to.be.lessThan(50)
+    expect(playlist).to.be.an.instanceOf(Playlist)
+    expect(playlist.length).to.be.a('number')
   })
 
   it('should work with fetching pages of subscriptions', async () => {
     const channel = await youtube.getChannel('UCg4XK-l40KZD7fLi12pJ1YA', [ 'id' ])
-    expect((await channel.fetchSubscriptions({ pages: 1 }, [ 'id' ])).items[0]).to.be.an.instanceOf(Subscription)
+    expect((await channel.fetchSubscriptions({ pages: 1 }, [ 'id' ]))
+      .items[0]).to.be.an.instanceOf(Subscription)
   })
 
   it('should work with fetching sections', async () => {
diff --git a/test/oauth/videos.spec.ts b/test/oauth/videos.spec.ts
index 4e389d2bc..f56891ff4 100644
--- a/test/oauth/videos.spec.ts
+++ b/test/oauth/videos.spec.ts
@@ -24,6 +24,15 @@ describe('OAuth videos', () => {
     expect(rating).to.equal('none')
   })
 
+  it('should cache ratings on videos', async () => {
+    const rating = video.getRating()
+    const start = new Date().getTime()
+
+    await rating
+
+    expect(new Date().getTime() - start).to.be.lessThan(50)
+  })
+
   it('should set thumbnails', async () => {
     if (!oauthVideoId) {
       expect.fail('The environment variable YOUTUBE_OAUTH_VIDEO_ID must be set for this test to be ran!')
diff --git a/test/parse.spec.ts b/test/parse.spec.ts
index f4ea57973..570de04c5 100644
--- a/test/parse.spec.ts
+++ b/test/parse.spec.ts
@@ -24,7 +24,7 @@ describe('Creation of the YouTube instance', () => {
       err = error.message
     }
 
-    expect(err).to.equal('Must include one of api key or access token whenever constructing the YouTube object.')
+    expect(err).to.equal('Must include one of API key or access token whenever constructing the YouTube object.')
   })
 })
 
diff --git a/test/search.spec.ts b/test/search.spec.ts
index 42a019f3a..eeba772e1 100644
--- a/test/search.spec.ts
+++ b/test/search.spec.ts
@@ -84,6 +84,17 @@ describe('Searching', () => {
     expect(video.channel.name).to.be.a('string')
   })
 
+  it('should work with caching', async () => {
+    let video: Video | Promise<PaginatedResponse<Video>> = youtube.searchVideos('bukkit', { searchFilters: { channel: 'UC6mi9rp7vRYninucP61qOjg' }, pageOptions: { maxPerPage: 1 } })
+    const time = new Date().getTime()
+
+    video = (await video).items[0]
+
+    expect(new Date().getTime() - time).to.be.lessThan(50)
+    expect(video.channel.id).to.equal('UC6mi9rp7vRYninucP61qOjg')
+    expect(video.channel.name).to.be.a('string')
+  })
+
   it('should return an array with a size of pages * maxPerPage', async () => {
     expect((await youtube.search('gaming moments', { pageOptions: { pages: 3, maxPerPage: 6 } })).items.length).to.equal(18)
   })