diff --git a/src/Ombi.Core/Engine/MovieSearchEngine.cs b/src/Ombi.Core/Engine/MovieSearchEngine.cs
index ce986a5f0..ef3638741 100644
--- a/src/Ombi.Core/Engine/MovieSearchEngine.cs
+++ b/src/Ombi.Core/Engine/MovieSearchEngine.cs
@@ -1,38 +1,39 @@
-using AutoMapper;
+using System;
+using AutoMapper;
 using Microsoft.Extensions.Logging;
 using Ombi.Api.TheMovieDb;
 using Ombi.Api.TheMovieDb.Models;
 using Ombi.Core.Models.Requests;
 using Ombi.Core.Models.Search;
-using Ombi.Core.Settings;
-using Ombi.Core.Settings.Models.External;
-using Ombi.Store.Repository;
 using System.Collections.Generic;
 using System.Linq;
 using System.Security.Principal;
 using System.Threading.Tasks;
 using Ombi.Core.Rule.Interfaces;
 using StackExchange.Profiling;
-using Ombi.Store.Entities;
-using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Caching.Memory;
+using Ombi.Api.Trakt;
 using Ombi.Core.Authentication;
+using Ombi.Helpers;
 
 namespace Ombi.Core.Engine
 {
     public class MovieSearchEngine : BaseMediaEngine, IMovieEngine
     {
         public MovieSearchEngine(IPrincipal identity, IRequestServiceMain service, IMovieDbApi movApi, IMapper mapper,
-            ILogger<MovieSearchEngine> logger, IRuleEvaluator r, OmbiUserManager um)
+            ILogger<MovieSearchEngine> logger, IRuleEvaluator r, OmbiUserManager um, IMemoryCache mem)
             : base(identity, service, r, um)
         {
             MovieApi = movApi;
             Mapper = mapper;
             Logger = logger;
+            MemCache = mem;
         }
 
         private IMovieDbApi MovieApi { get; }
         private IMapper Mapper { get; }
         private ILogger<MovieSearchEngine> Logger { get; }
+        private IMemoryCache MemCache { get; }
 
         /// <summary>
         /// Lookups the imdb information.
@@ -78,7 +79,11 @@ namespace Ombi.Core.Engine
         /// <returns></returns>
         public async Task<IEnumerable<SearchMovieViewModel>> PopularMovies()
         {
-            var result = await MovieApi.PopularMovies();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.PopularMovies, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await MovieApi.PopularMovies();
+            });
             if (result != null)
             {
                 Logger.LogDebug("Search Result: {result}", result);
@@ -93,7 +98,11 @@ namespace Ombi.Core.Engine
         /// <returns></returns>
         public async Task<IEnumerable<SearchMovieViewModel>> TopRatedMovies()
         {
-            var result = await MovieApi.TopRated();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.TopRatedMovies, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await MovieApi.TopRated();
+            });
             if (result != null)
             {
                 Logger.LogDebug("Search Result: {result}", result);
@@ -108,7 +117,11 @@ namespace Ombi.Core.Engine
         /// <returns></returns>
         public async Task<IEnumerable<SearchMovieViewModel>> UpcomingMovies()
         {
-            var result = await MovieApi.Upcoming();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.UpcomingMovies, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await MovieApi.Upcoming();
+            });
             if (result != null)
             {
                 Logger.LogDebug("Search Result: {result}", result);
@@ -123,7 +136,11 @@ namespace Ombi.Core.Engine
         /// <returns></returns>
         public async Task<IEnumerable<SearchMovieViewModel>> NowPlayingMovies()
         {
-            var result = await MovieApi.NowPlaying();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.NowPlayingMovies, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await MovieApi.NowPlaying();
+            });
             if (result != null)
             {
                 Logger.LogDebug("Search Result: {result}", result);
diff --git a/src/Ombi.Core/Engine/TvSearchEngine.cs b/src/Ombi.Core/Engine/TvSearchEngine.cs
index 83ba0843d..cf5d1ef3c 100644
--- a/src/Ombi.Core/Engine/TvSearchEngine.cs
+++ b/src/Ombi.Core/Engine/TvSearchEngine.cs
@@ -20,14 +20,17 @@ using Ombi.Store.Repository.Requests;
 using Ombi.Store.Entities;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
 using Ombi.Core.Authentication;
+using Ombi.Helpers;
 
 namespace Ombi.Core.Engine
 {
     public class TvSearchEngine : BaseMediaEngine, ITvSearchEngine
     {
         public TvSearchEngine(IPrincipal identity, IRequestServiceMain service, ITvMazeApi tvMaze, IMapper mapper, ISettingsService<PlexSettings> plexSettings,
-            ISettingsService<EmbySettings> embySettings, IPlexContentRepository repo, IEmbyContentRepository embyRepo, ITraktApi trakt, IRuleEvaluator r, OmbiUserManager um)
+            ISettingsService<EmbySettings> embySettings, IPlexContentRepository repo, IEmbyContentRepository embyRepo, ITraktApi trakt, IRuleEvaluator r, OmbiUserManager um,
+            IMemoryCache memCache)
             : base(identity, service, r, um)
         {
             TvMazeApi = tvMaze;
@@ -37,6 +40,7 @@ namespace Ombi.Core.Engine
             PlexContentRepo = repo;
             TraktApi = trakt;
             EmbyContentRepo = embyRepo;
+            MemCache = memCache;
         }
 
         private ITvMazeApi TvMazeApi { get; }
@@ -46,6 +50,7 @@ namespace Ombi.Core.Engine
         private IPlexContentRepository PlexContentRepo { get; }
         private IEmbyContentRepository EmbyContentRepo { get; }
         private ITraktApi TraktApi { get; }
+        private IMemoryCache MemCache { get; }
 
         public async Task<IEnumerable<SearchTvShowViewModel>> Search(string searchTerm)
         {
@@ -127,28 +132,44 @@ namespace Ombi.Core.Engine
 
         public async Task<IEnumerable<TreeNode<SearchTvShowViewModel>>> Popular()
         {
-            var result = await TraktApi.GetPopularShows();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.PopularTv, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await TraktApi.GetPopularShows();
+            });
             var processed = await ProcessResults(result);
             return processed.Select(ParseIntoTreeNode).ToList();
         }
 
         public async Task<IEnumerable<TreeNode<SearchTvShowViewModel>>> Anticipated()
         {
-            var result = await TraktApi.GetAnticipatedShows();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.AnticipatedTv, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await TraktApi.GetAnticipatedShows();
+            });
             var processed= await ProcessResults(result);
             return processed.Select(ParseIntoTreeNode).ToList();
         }
 
         public async Task<IEnumerable<TreeNode<SearchTvShowViewModel>>> MostWatches()
         {
-            var result = await TraktApi.GetMostWatchesShows();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.MostWatchesTv, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await TraktApi.GetMostWatchesShows();
+            });
             var processed = await ProcessResults(result);
             return processed.Select(ParseIntoTreeNode).ToList();
         }
 
         public async Task<IEnumerable<TreeNode<SearchTvShowViewModel>>> Trending()
         {
-            var result = await TraktApi.GetTrendingShows();
+            var result = await MemCache.GetOrCreateAsync(CacheKeys.TrendingTv, async entry =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.Now.AddHours(12);
+                return await TraktApi.GetTrendingShows();
+            });
             var processed = await ProcessResults(result);
             return processed.Select(ParseIntoTreeNode).ToList();
         }
diff --git a/src/Ombi.Helpers/CacheKeys.cs b/src/Ombi.Helpers/CacheKeys.cs
index 1466d425e..f1c64fa38 100644
--- a/src/Ombi.Helpers/CacheKeys.cs
+++ b/src/Ombi.Helpers/CacheKeys.cs
@@ -8,5 +8,13 @@ namespace Ombi.Helpers
     {
         public const string Update = nameof(Update);
         public const string OmbiSettings = nameof(OmbiSettings);
+        public const string PopularTv = nameof(PopularTv);
+        public const string AnticipatedTv = nameof(AnticipatedTv);
+        public const string MostWatchesTv = nameof(MostWatchesTv);
+        public const string TrendingTv = nameof(TrendingTv);
+        public const string PopularMovies = nameof(PopularMovies);
+        public const string TopRatedMovies = nameof(TopRatedMovies);
+        public const string UpcomingMovies = nameof(UpcomingMovies);
+        public const string NowPlayingMovies = nameof(NowPlayingMovies);
     }
 }
diff --git a/src/Ombi.Store/Repository/Requests/TvRequestRepository.cs b/src/Ombi.Store/Repository/Requests/TvRequestRepository.cs
index a89a88dec..0f0a914c5 100644
--- a/src/Ombi.Store/Repository/Requests/TvRequestRepository.cs
+++ b/src/Ombi.Store/Repository/Requests/TvRequestRepository.cs
@@ -91,15 +91,15 @@ namespace Ombi.Store.Repository.Requests
 
         public async Task Update(TvRequests request)
         {
-            Db.Attach(request).State = EntityState.Modified;
+            Db.Update(request);
             
             await Db.SaveChangesAsync();
         }
         
         public async Task UpdateChild(ChildRequests request)
         {
-            Db.Attach(request).State = EntityState.Modified;
-            
+            Db.Update(request);
+
             await Db.SaveChangesAsync();
         }
     }