diff --git a/lyric_search_new/sources/cache.py b/lyric_search_new/sources/cache.py
index 776e943..5bca79c 100644
--- a/lyric_search_new/sources/cache.py
+++ b/lyric_search_new/sources/cache.py
@@ -42,9 +42,10 @@ class Cache:
         """Get Matched Result"""
         matched_id: int = matched_candidate[0]
         if redis_results:
-            logging.info("Matched id: %s", matched_id)
-            for row in redis_results:
-                if row['id'] == matched_id:
+            for res in redis_results:
+                (key, row) = res
+                if key == matched_id:
+                    logging.info("Matched row: %s", row)
                     return LyricsResult(
                         artist=row['artist'],
                         song=row['song'],
@@ -137,11 +138,17 @@ class Cache:
             artist: str = artist.strip().lower() 
             song: str  = song.strip().lower()
             input_track: str = f"{artist} - {song}"
+            search_query = None
             search_params: Optional[tuple] = None
             random_search: bool = False
             time_start: float = time.time()
             matcher = utils.TrackMatcher()
 
+            if artist == "!" and song == "!":
+                random_search = True
+                search_query: str = 'SELECT id, artist, song, lyrics, src, confidence\
+                FROM lyrics ORDER BY RANDOM() LIMIT 1'                
+
             logging.info("Searching %s - %s on %s",
                          artist, song, self.label) 
             
@@ -154,11 +161,19 @@ class Cache:
             
             if redis_result:
                 result_tracks: list = []
-                for track in redis_result:
-                    result_tracks.append((track['id'], f"{track['artist']} - {track['song']}"))                
+                for returned in redis_result:
+                    (key, track) = returned
+                    result_tracks.append((key, f"{track['artist']} - {track['song']}"))                
                 
-                best_match: tuple|None = matcher.find_best_match(input_track=input_track,
+                if not random_search:
+                    best_match: tuple|None = matcher.find_best_match(input_track=input_track,
                                                                  candidate_tracks=result_tracks)
+                else:
+                    best_match = (result_tracks[0], 100)
+                
+                if not best_match:
+                    return None
+                
                 (candidate, confidence) = best_match
                 matched = self.get_matched(redis_results=redis_result, matched_candidate=candidate,
                                           confidence=confidence)                  
@@ -179,16 +194,13 @@ class Cache:
                 for ext in self.sqlite_exts:
                     await db_conn.load_extension(ext)
                 async with await db_conn.executescript(self.cache_pre_query) as _db_cursor:
-                    search_query: str = 'SELECT id, artist, song, lyrics, src, confidence FROM lyrics\
+                    if not random_search:
+                        search_query: str = 'SELECT id, artist, song, lyrics, src, confidence FROM lyrics\
                         WHERE editdist3((lower(artist) || " " || lower(song)), (? || " " || ?))\
                         <= 410 ORDER BY editdist3((lower(artist) || " " || lower(song)), ?) ASC LIMIT 10'
-                    search_params: tuple = (artist.strip(), song.strip(),
-                                    f"{artist.strip()} {song.strip()}")                    
-                    if artist == "!" and song == "!":
-                        random_search: bool = True
-                        search_query: str = 'SELECT id, artist, song, lyrics, src, confidence\
-                            FROM lyrics ORDER BY RANDOM() LIMIT 1'
-                        search_params = None
+                        search_params: tuple = (artist.strip(), song.strip(),
+                                    f"{artist.strip()} {song.strip()}") 
+                                           
                     async with await _db_cursor.execute(search_query, search_params) as db_cursor:
                         results: list = await db_cursor.fetchall()
                         result_tracks: list = []
diff --git a/lyric_search_new/sources/redis_cache.py b/lyric_search_new/sources/redis_cache.py
index 097cf5c..63e868e 100644
--- a/lyric_search_new/sources/redis_cache.py
+++ b/lyric_search_new/sources/redis_cache.py
@@ -52,19 +52,25 @@ class RedisCache:
         """
 
         try:
-            artist = kwargs.get('artist')
-            song = kwargs.get('song')
+            artist = kwargs.get('artist', '')
+            song = kwargs.get('song', '')
             lyrics = kwargs.get('lyrics')
+            is_random_search = artist == "!" and song == "!"
 
             if lyrics:
                 # to code later
                 raise RedisException("Lyric search not yet implemented")
             
-            search_res = await self.redis_client.ft().search(
-                Query(f"@artist:{artist} @song:{song}"
-        )) 
-            search_res_out = [dict(json.loads(result['json']))
-                              for result in search_res.docs]
+            if not is_random_search:
+                search_res = await self.redis_client.ft().search(
+                    Query(f"@artist:{artist} @song:{song}"
+                          )) 
+                search_res_out = [(result['id'], dict(json.loads(result['json'])))
+                                  for result in search_res.docs]
+            else:
+                random_redis_key = await self.redis_client.randomkey()
+                search_res = await self.redis_client.json().get(random_redis_key)
+                search_res_out = [(random_redis_key, search_res)]
             
             return search_res_out
         except: