diff --git a/app/api/endpoints/tmdb.py b/app/api/endpoints/tmdb.py
index 701caddb..b74c34fc 100644
--- a/app/api/endpoints/tmdb.py
+++ b/app/api/endpoints/tmdb.py
@@ -11,28 +11,28 @@ router = APIRouter()
 
 
 @router.get("/seasons/{tmdbid}", summary="TMDB所有季", response_model=List[schemas.TmdbSeason])
-def tmdb_seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询themoviedb所有季信息
     """
-    seasons_info = TmdbChain().tmdb_seasons(tmdbid=tmdbid)
+    seasons_info = await TmdbChain().async_tmdb_seasons(tmdbid=tmdbid)
     if seasons_info:
         return seasons_info
     return []
 
 
 @router.get("/similar/{tmdbid}/{type_name}", summary="类似电影/电视剧", response_model=List[schemas.MediaInfo])
-def tmdb_similar(tmdbid: int,
-                 type_name: str,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_similar(tmdbid: int,
+                       type_name: str,
+                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询类似电影/电视剧，type_name: 电影/电视剧
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        medias = TmdbChain().movie_similar(tmdbid=tmdbid)
+        medias = await TmdbChain().async_movie_similar(tmdbid=tmdbid)
     elif mediatype == MediaType.TV:
-        medias = TmdbChain().tv_similar(tmdbid=tmdbid)
+        medias = await TmdbChain().async_tv_similar(tmdbid=tmdbid)
     else:
         return []
     if medias:
@@ -41,17 +41,17 @@ def tmdb_similar(tmdbid: int,
 
 
 @router.get("/recommend/{tmdbid}/{type_name}", summary="推荐电影/电视剧", response_model=List[schemas.MediaInfo])
-def tmdb_recommend(tmdbid: int,
-                   type_name: str,
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_recommend(tmdbid: int,
+                         type_name: str,
+                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询推荐电影/电视剧，type_name: 电影/电视剧
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        medias = TmdbChain().movie_recommend(tmdbid=tmdbid)
+        medias = await TmdbChain().async_movie_recommend(tmdbid=tmdbid)
     elif mediatype == MediaType.TV:
-        medias = TmdbChain().tv_recommend(tmdbid=tmdbid)
+        medias = await TmdbChain().async_tv_recommend(tmdbid=tmdbid)
     else:
         return []
     if medias:
@@ -60,63 +60,63 @@ def tmdb_recommend(tmdbid: int,
 
 
 @router.get("/collection/{collection_id}", summary="系列合集详情", response_model=List[schemas.MediaInfo])
-def tmdb_collection(collection_id: int,
-                    page: Optional[int] = 1,
-                    count: Optional[int] = 20,
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_collection(collection_id: int,
+                          page: Optional[int] = 1,
+                          count: Optional[int] = 20,
+                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据合集ID查询合集详情
     """
-    medias = TmdbChain().tmdb_collection(collection_id=collection_id)
+    medias = await TmdbChain().async_tmdb_collection(collection_id=collection_id)
     if medias:
         return [media.to_dict() for media in medias][(page - 1) * count:page * count]
     return []
 
 
 @router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.MediaPerson])
-def tmdb_credits(tmdbid: int,
-                 type_name: str,
-                 page: Optional[int] = 1,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_credits(tmdbid: int,
+                       type_name: str,
+                       page: Optional[int] = 1,
+                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询演员阵容，type_name: 电影/电视剧
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        persons = TmdbChain().movie_credits(tmdbid=tmdbid, page=page)
+        persons = await TmdbChain().async_movie_credits(tmdbid=tmdbid, page=page)
     elif mediatype == MediaType.TV:
-        persons = TmdbChain().tv_credits(tmdbid=tmdbid, page=page)
+        persons = await TmdbChain().async_tv_credits(tmdbid=tmdbid, page=page)
     else:
         return []
     return persons or []
 
 
 @router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
-def tmdb_person(person_id: int,
-                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_person(person_id: int,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物详情
     """
-    return TmdbChain().person_detail(person_id=person_id)
+    return await TmdbChain().async_person_detail(person_id=person_id)
 
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
-def tmdb_person_credits(person_id: int,
-                        page: Optional[int] = 1,
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_person_credits(person_id: int,
+                              page: Optional[int] = 1,
+                              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
     """
-    medias = TmdbChain().person_credits(person_id=person_id, page=page)
+    medias = await TmdbChain().async_person_credits(person_id=person_id, page=page)
     if medias:
         return [media.to_dict() for media in medias]
     return []
 
 
 @router.get("/{tmdbid}/{season}", summary="TMDB季所有集", response_model=List[schemas.TmdbEpisode])
-def tmdb_season_episodes(tmdbid: int, season: int, episode_group: Optional[str] = None,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def tmdb_season_episodes(tmdbid: int, season: int, episode_group: Optional[str] = None,
+                               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询某季的所有信信息
     """
-    return TmdbChain().tmdb_episodes(tmdbid=tmdbid, season=season, episode_group=episode_group)
+    return await TmdbChain().async_tmdb_episodes(tmdbid=tmdbid, season=season, episode_group=episode_group)
diff --git a/app/chain/tmdb.py b/app/chain/tmdb.py
index d7fc14eb..42cb8dda 100644
--- a/app/chain/tmdb.py
+++ b/app/chain/tmdb.py
@@ -164,3 +164,158 @@ class TmdbChain(ChainBase):
         if infos:
             return [info.backdrop_path for info in infos if info and info.backdrop_path][:num]
         return []
+
+    async def async_tmdb_discover(self, mtype: MediaType,
+                                  sort_by: str,
+                                  with_genres: str,
+                                  with_original_language: str,
+                                  with_keywords: str,
+                                  with_watch_providers: str,
+                                  vote_average: float,
+                                  vote_count: int,
+                                  release_date: str,
+                                  page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
+        """
+        发现TMDB电影、剧集（异步版本）
+        :param mtype:  媒体类型
+        :param sort_by:  排序方式
+        :param with_genres:  类型
+        :param with_original_language:  语言
+        :param with_keywords:  关键字
+        :param with_watch_providers:  提供商
+        :param vote_average:  评分
+        :param vote_count:  评分人数
+        :param release_date:  上映日期
+        :param page:  页码
+        :return: 媒体信息列表
+        """
+        return await self.run_module("async_tmdb_discover", mtype=mtype,
+                                     sort_by=sort_by,
+                                     with_genres=with_genres,
+                                     with_original_language=with_original_language,
+                                     with_keywords=with_keywords,
+                                     with_watch_providers=with_watch_providers,
+                                     vote_average=vote_average,
+                                     vote_count=vote_count,
+                                     release_date=release_date,
+                                     page=page)
+
+    async def async_tmdb_trending(self, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
+        """
+        TMDB流行趋势（异步版本）
+        :param page: 第几页
+        :return: TMDB信息列表
+        """
+        return await self.run_module("async_tmdb_trending", page=page)
+
+    async def async_tmdb_collection(self, collection_id: int) -> Optional[List[MediaInfo]]:
+        """
+        根据合集ID查询集合（异步版本）
+        :param collection_id:  合集ID
+        """
+        return await self.run_module("async_tmdb_collection", collection_id=collection_id)
+
+    async def async_tmdb_seasons(self, tmdbid: int) -> List[schemas.TmdbSeason]:
+        """
+        根据TMDBID查询themoviedb所有季信息（异步版本）
+        :param tmdbid:  TMDBID
+        """
+        return await self.run_module("async_tmdb_seasons", tmdbid=tmdbid)
+
+    async def async_tmdb_group_seasons(self, group_id: str) -> List[schemas.TmdbSeason]:
+        """
+        根据剧集组ID查询themoviedb所有季集信息（异步版本）
+        :param group_id: 剧集组ID
+        """
+        return await self.run_module("async_tmdb_group_seasons", group_id=group_id)
+
+    async def async_tmdb_episodes(self, tmdbid: int, season: int,
+                                  episode_group: Optional[str] = None) -> List[schemas.TmdbEpisode]:
+        """
+        根据TMDBID查询某季的所有信信息（异步版本）
+        :param tmdbid:  TMDBID
+        :param season:  季
+        :param episode_group:  剧集组
+        """
+        return await self.run_module("async_tmdb_episodes", tmdbid=tmdbid, season=season, episode_group=episode_group)
+
+    async def async_movie_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
+        """
+        根据TMDBID查询类似电影（异步版本）
+        :param tmdbid:  TMDBID
+        """
+        return await self.run_module("async_tmdb_movie_similar", tmdbid=tmdbid)
+
+    async def async_tv_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
+        """
+        根据TMDBID查询类似电视剧（异步版本）
+        :param tmdbid:  TMDBID
+        """
+        return await self.run_module("async_tmdb_tv_similar", tmdbid=tmdbid)
+
+    async def async_movie_recommend(self, tmdbid: int) -> Optional[List[MediaInfo]]:
+        """
+        根据TMDBID查询推荐电影（异步版本）
+        :param tmdbid:  TMDBID
+        """
+        return await self.run_module("async_tmdb_movie_recommend", tmdbid=tmdbid)
+
+    async def async_tv_recommend(self, tmdbid: int) -> Optional[List[MediaInfo]]:
+        """
+        根据TMDBID查询推荐电视剧（异步版本）
+        :param tmdbid:  TMDBID
+        """
+        return await self.run_module("async_tmdb_tv_recommend", tmdbid=tmdbid)
+
+    async def async_movie_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
+        """
+        根据TMDBID查询电影演职人员（异步版本）
+        :param tmdbid:  TMDBID
+        :param page:  页码
+        """
+        return await self.run_module("async_tmdb_movie_credits", tmdbid=tmdbid, page=page)
+
+    async def async_tv_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
+        """
+        根据TMDBID查询电视剧演职人员（异步版本）
+        :param tmdbid:  TMDBID
+        :param page:  页码
+        """
+        return await self.run_module("async_tmdb_tv_credits", tmdbid=tmdbid, page=page)
+
+    async def async_person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
+        """
+        根据TMDBID查询演职员详情（异步版本）
+        :param person_id:  人物ID
+        """
+        return await self.run_module("async_tmdb_person_detail", person_id=person_id)
+
+    async def async_person_credits(self, person_id: int, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
+        """
+        根据人物ID查询人物参演作品（异步版本）
+        :param person_id:  人物ID
+        :param page:  页码
+        """
+        return await self.run_module("async_tmdb_person_credits", person_id=person_id, page=page)
+
+    async def async_get_random_wallpager(self) -> Optional[str]:
+        """
+        获取随机壁纸（异步版本），缓存1个小时
+        """
+        infos = await self.async_tmdb_trending()
+        if infos:
+            # 随机一个电影
+            while True:
+                info = random.choice(infos)
+                if info and info.backdrop_path:
+                    return info.backdrop_path
+        return None
+
+    async def async_get_trending_wallpapers(self, num: Optional[int] = 10) -> List[str]:
+        """
+        获取所有流行壁纸（异步版本）
+        """
+        infos = await self.async_tmdb_trending()
+        if infos:
+            return [info.backdrop_path for info in infos if info and info.backdrop_path][:num]
+        return []
diff --git a/app/modules/douban/__init__.py b/app/modules/douban/__init__.py
index c5029e49..a297c8b3 100644
--- a/app/modules/douban/__init__.py
+++ b/app/modules/douban/__init__.py
@@ -486,8 +486,8 @@ class DoubanModule(_ModuleBase):
             return __douban_movie() or __douban_tv()
 
     @rate_limit_exponential(source="douban_info")
-    async def async_douban_info(self, doubanid: str, mtype: MediaType = None, raise_exception: bool = True) -> Optional[
-        dict]:
+    async def async_douban_info(self, doubanid: str, mtype: MediaType = None,
+                                raise_exception: bool = True) -> Optional[dict]:
         """
         获取豆瓣信息（异步版本）
         :param doubanid: 豆瓣ID