diff --git a/src/services/activity.py b/src/services/activity.py
index 6ad810e9..ae2ece70 100644
--- a/src/services/activity.py
+++ b/src/services/activity.py
@@ -35,13 +35,13 @@ async def create_activity(request: Request, user: PublicUser, activity_object: A
     activities = request.app.db["activities"]
 
     # find if the user has already started the course
-    isActivityAlreadCreated = activities.find_one(
+    isActivityAlreadCreated = await activities.find_one(
         {"course_id": activity_object.course_id, "user_id": user.user_id})
 
     if isActivityAlreadCreated:
         if isActivityAlreadCreated['status'] == 'closed':
             activity_object.status = 'ongoing'
-            activities.update_one(
+            await activities.update_one(
                 {"activity_id": isActivityAlreadCreated['activity_id']}, {"$set": activity_object.dict()})
             return activity_object
         else:
@@ -54,7 +54,7 @@ async def create_activity(request: Request, user: PublicUser, activity_object: A
     activity = ActivityInDB(**activity_object.dict(),activity_id=activity_id,
                             user_id=user.user_id, org_id=activity_object.course_id)
 
-    activities.insert_one(activity.dict())
+    await activities.insert_one(activity.dict())
 
     return activity
 
@@ -73,7 +73,7 @@ async def get_user_activities(request: Request, user: PublicUser, org_id: str):
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="No activities found")
 
-    for activity in user_activities:
+    for activity in await user_activities.to_list(length=100):
         # get number of lectures in the course
         coursechapters = await get_coursechapters_meta(request, activity['course_id'], user)
 
@@ -81,7 +81,7 @@ async def get_user_activities(request: Request, user: PublicUser, org_id: str):
         progression = round(
             len(activity['lectures_marked_complete']) / len(coursechapters['lectures']) * 100, 2)  
 
-        course = courses.find_one({"course_id": activity['course_id']}, {'_id': 0})
+        course = await courses.find_one({"course_id": activity['course_id']}, {'_id': 0})
 
         # add progression to the activity
         one_activity = {"course": course,  "activitydata": activity, "progression": progression}
@@ -103,7 +103,7 @@ async def get_user_activities_orgslug(request: Request, user: PublicUser, org_sl
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="No activities found")
 
-    for activity in user_activities:
+    for activity in await user_activities.to_list(length=100):
         # get number of lectures in the course
         coursechapters = await get_coursechapters_meta(request, activity['course_id'], user)
 
@@ -111,7 +111,7 @@ async def get_user_activities_orgslug(request: Request, user: PublicUser, org_sl
         progression = round(
             len(activity['lectures_marked_complete']) / len(coursechapters['lectures']) * 100, 2)  
 
-        course = courses.find_one({"course_id": activity['course_id']}, {'_id': 0})
+        course = await courses.find_one({"course_id": activity['course_id']}, {'_id': 0})
 
         # add progression to the activity
         one_activity = {"course": course,  "activitydata": activity, "progression": progression}
@@ -125,14 +125,14 @@ async def add_lecture_to_activity(request: Request, user: PublicUser, org_id: st
     course_id = f"course_{course_id}"
     lecture_id = f"lecture_{lecture_id}"
    
-    activity = activities.find_one(
+    activity = await activities.find_one(
         {"course_id": course_id,
             "user_id": user.user_id
          },  {'_id': 0})
 
     if lecture_id not in activity['lectures_marked_complete']:
         activity['lectures_marked_complete'].append(str(lecture_id))
-        activities.update_one(
+        await activities.update_one(
             {"activity_id": activity['activity_id']}, {"$set": activity})
         return activity
 
@@ -147,7 +147,7 @@ async def add_lecture_to_activity(request: Request, user: PublicUser, org_id: st
 
 async def close_activity(request: Request, user: PublicUser,  activity_id: str, org_id: str,):
     activities = request.app.db["activities"]
-    activity = activities.find_one(
+    activity = await activities.find_one(
         {"activity_id": activity_id, "user_id": user.user_id})
 
     if not activity:
@@ -156,7 +156,7 @@ async def close_activity(request: Request, user: PublicUser,  activity_id: str,
 
     activity['status'] = 'closed'
 
-    activities.update_one(
+    await activities.update_one(
         {"activity_id": activity['activity_id']}, {"$set": activity})
 
     activity = ActivityInDB(**activity)
diff --git a/src/services/blocks/imageBlock/images.py b/src/services/blocks/imageBlock/images.py
index 38869fcb..be8104b9 100644
--- a/src/services/blocks/imageBlock/images.py
+++ b/src/services/blocks/imageBlock/images.py
@@ -62,7 +62,7 @@ async def create_image_file(request: Request,image_file: UploadFile, lecture_id:
         f.close()
 
     # insert file object into database
-    photo_file_in_db = photos.insert_one(uploadable_file.dict())
+    photo_file_in_db = await photos.insert_one(uploadable_file.dict())
 
     if not photo_file_in_db:
         raise HTTPException(
@@ -74,7 +74,7 @@ async def create_image_file(request: Request,image_file: UploadFile, lecture_id:
 async def get_image_object(request: Request,file_id: str):
     photos = request.app.db["files"]
 
-    photo_file = photos.find_one({"file_id": file_id})
+    photo_file = await photos.find_one({"file_id": file_id})
 
     if photo_file:
         photo_file = PhotoFile(**photo_file)
@@ -88,7 +88,7 @@ async def get_image_object(request: Request,file_id: str):
 async def get_image_file(request: Request,file_id: str, current_user: PublicUser):
     photos = request.app.db["files"]
 
-    photo_file = photos.find_one({"file_id": file_id})
+    photo_file = await photos.find_one({"file_id": file_id})
 
     # TODO : check if user has access to file
 
diff --git a/src/services/blocks/pdfBlock/documents.py b/src/services/blocks/pdfBlock/documents.py
index a739bb32..0f061ecd 100644
--- a/src/services/blocks/pdfBlock/documents.py
+++ b/src/services/blocks/pdfBlock/documents.py
@@ -62,7 +62,7 @@ async def create_document_file(request: Request, document_file: UploadFile, lect
         f.close()
 
     # insert file object into database
-    document_file_in_db = documents.insert_one(uploadable_file.dict())
+    document_file_in_db = await documents.insert_one(uploadable_file.dict())
 
     if not document_file_in_db:
         raise HTTPException(
@@ -74,7 +74,7 @@ async def create_document_file(request: Request, document_file: UploadFile, lect
 async def get_document_object(request: Request, file_id: str):
     documents = request.app.db["files"]
 
-    document_file = documents.find_one({"file_id": file_id})
+    document_file = await documents.find_one({"file_id": file_id})
 
     if document_file:
         document_file = DocumentFile(**document_file)
@@ -88,7 +88,7 @@ async def get_document_object(request: Request, file_id: str):
 async def get_document_file(request: Request, file_id: str, current_user: PublicUser):
     documents = request.app.db["files"]
 
-    document_file = documents.find_one({"file_id": file_id})
+    document_file = await documents.find_one({"file_id": file_id})
 
     # TODO : check if user has access to file
 
diff --git a/src/services/blocks/quizBlock/quizBlock.py b/src/services/blocks/quizBlock/quizBlock.py
index 3bcb9d73..d1f0cecb 100644
--- a/src/services/blocks/quizBlock/quizBlock.py
+++ b/src/services/blocks/quizBlock/quizBlock.py
@@ -37,7 +37,7 @@ async def create_quiz_block(request: Request, quizBlock: quizBlock, lecture_id:
                   block_type="quizBlock", block_data=quizBlock)
 
     # insert block
-    blocks.insert_one(block.dict())
+    await blocks.insert_one(block.dict())
 
     return block
 
@@ -45,7 +45,7 @@ async def create_quiz_block(request: Request, quizBlock: quizBlock, lecture_id:
 async def get_quiz_block_options(request: Request, block_id: str, user: PublicUser):
     blocks = request.app.db["blocks"]
     # find block but get only the options
-    block = blocks.find_one({"block_id": block_id, }, {
+    block = await blocks.find_one({"block_id": block_id, }, {
                             "_id": 0, "block_data.answers": 0})
 
     return block
@@ -54,7 +54,7 @@ async def get_quiz_block_answers(request: Request, block_id: str, user: PublicUs
     blocks = request.app.db["blocks"]
     
     # find block but get only the answers
-    block = blocks.find_one({"block_id": block_id, }, {
+    block = await blocks.find_one({"block_id": block_id, }, {
                             "_id": 0, "block_data.questions": 0})
 
     return block
diff --git a/src/services/blocks/videoBlock/videos.py b/src/services/blocks/videoBlock/videos.py
index dd194c1d..b703013f 100644
--- a/src/services/blocks/videoBlock/videos.py
+++ b/src/services/blocks/videoBlock/videos.py
@@ -62,7 +62,7 @@ async def create_video_file(request: Request,video_file: UploadFile, lecture_id:
         f.close()
 
     # insert file object into database
-    video_file_in_db = files.insert_one(uploadable_file.dict())
+    video_file_in_db = await files.insert_one(uploadable_file.dict())
 
     if not video_file_in_db:
         raise HTTPException(
@@ -74,7 +74,7 @@ async def create_video_file(request: Request,video_file: UploadFile, lecture_id:
 async def get_video_object(request: Request,file_id: str, current_user: PublicUser):
     photos = request.app.db["files"]
 
-    video_file = photos.find_one({"file_id": file_id})
+    video_file = await photos.find_one({"file_id": file_id})
 
     if video_file:
         video_file = VideoFile(**video_file)
@@ -88,7 +88,7 @@ async def get_video_object(request: Request,file_id: str, current_user: PublicUs
 async def get_video_file(request: Request,file_id: str, current_user: PublicUser):
     photos = request.app.db["files"]
 
-    video_file = photos.find_one({"file_id": file_id})
+    video_file = await photos.find_one({"file_id": file_id})
 
     # TODO : check if user has access to file
 
diff --git a/src/services/courses/chapters.py b/src/services/courses/chapters.py
index 67a6e17f..bda0aeff 100644
--- a/src/services/courses/chapters.py
+++ b/src/services/courses/chapters.py
@@ -52,7 +52,7 @@ async def create_coursechapter(request: Request,coursechapter_object: CourseChap
     coursechapter = CourseChapterInDB(coursechapter_id=coursechapter_id, creationDate=str(
         datetime.now()), updateDate=str(datetime.now()), course_id=course_id, **coursechapter_object.dict())
 
-    coursechapter_in_db = coursechapters.insert_one(coursechapter.dict())
+    coursechapter_in_db = await coursechapters.insert_one(coursechapter.dict())
     courses.update_one({"course_id": course_id}, {
                        "$addToSet": {"chapters": coursechapter_id}})
 
@@ -66,7 +66,7 @@ async def create_coursechapter(request: Request,coursechapter_object: CourseChap
 async def get_coursechapter(request: Request,coursechapter_id: str, current_user: PublicUser):
     coursechapters = request.app.db["coursechapters"]
 
-    coursechapter = coursechapters.find_one(
+    coursechapter = await coursechapters.find_one(
         {"coursechapter_id": coursechapter_id})
 
     if coursechapter:
@@ -84,7 +84,7 @@ async def get_coursechapter(request: Request,coursechapter_id: str, current_user
 async def update_coursechapter(request: Request,coursechapter_object: CourseChapter,  coursechapter_id: str, current_user: PublicUser):
     coursechapters = request.app.db["coursechapters"]
 
-    coursechapter = coursechapters.find_one(
+    coursechapter = await coursechapters.find_one(
         {"coursechapter_id": coursechapter_id})
 
     if coursechapter:
@@ -98,7 +98,7 @@ async def update_coursechapter(request: Request,coursechapter_object: CourseChap
         updated_coursechapter = CourseChapterInDB(
             coursechapter_id=coursechapter_id, creationDate=creationDate, course_id=coursechapter["course_id"], updateDate=str(datetime_object), **coursechapter_object.dict())
 
-        coursechapters.update_one({"coursechapter_id": coursechapter_id}, {
+        await coursechapters.update_one({"coursechapter_id": coursechapter_id}, {
             "$set": updated_coursechapter.dict()})
 
         return CourseChapterInDB(**updated_coursechapter.dict())
@@ -113,18 +113,18 @@ async def delete_coursechapter(request: Request,coursechapter_id: str,  current_
     coursechapters = request.app.db["coursechapters"]
     courses = request.app.db["courses"]
 
-    coursechapter = coursechapters.find_one(
+    coursechapter = await coursechapters.find_one(
         {"coursechapter_id": coursechapter_id})
 
     if coursechapter:
         # verify course rights
         await verify_rights(request, coursechapter["course_id"], current_user, "delete")
 
-        isDeleted = coursechapters.delete_one(
+        isDeleted = await coursechapters.delete_one(
             {"coursechapter_id": coursechapter_id})
 
         # Remove coursechapter from course
-        courses.update_one({"course_id": coursechapter["course_id"]}, {
+        await courses.update_one({"course_id": coursechapter["course_id"]}, {
             "$pull": {"chapters": coursechapter_id}})
 
         if isDeleted:
@@ -149,7 +149,7 @@ async def get_coursechapters(request: Request,course_id: str, page: int = 1, lim
     all_coursechapters = courses.find({"course_id": course_id}).sort(
         "name", 1).skip(10 * (page - 1)).limit(limit)
 
-    return [json.loads(json.dumps(coursechapter, default=str)) for coursechapter in all_coursechapters]
+    return [json.loads(json.dumps(coursechapter, default=str)) for coursechapter in await all_coursechapters.to_list(length=100)]
 
 
 async def get_coursechapters_meta(request: Request, course_id: str, current_user: PublicUser):
@@ -160,7 +160,7 @@ async def get_coursechapters_meta(request: Request, course_id: str, current_user
     coursechapters = coursechapters.find(
         {"course_id": course_id}).sort("name", 1)
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
     course = Course(**course)  # type: ignore
 
     # lectures
@@ -168,7 +168,7 @@ async def get_coursechapters_meta(request: Request, course_id: str, current_user
 
     # chapters
     chapters = {}
-    for coursechapter in coursechapters:
+    for coursechapter in await coursechapters.to_list(length=100):
         coursechapter = CourseChapterInDB(**coursechapter)
         coursechapter_lectureIds = []
 
@@ -182,7 +182,7 @@ async def get_coursechapters_meta(request: Request, course_id: str, current_user
 
     # lectures
     lectures_list = {}
-    for lecture in lectures.find({"lecture_id": {"$in": coursechapter_lectureIds_global}}):
+    for lecture in await lectures.find({"lecture_id": {"$in": coursechapter_lectureIds_global}}).to_list(length=100):
         lecture = LectureInDB(**lecture)
         lectures_list[lecture.lecture_id] = {
             "id": lecture.lecture_id, "name": lecture.name, "type": lecture.type, "content": lecture.content
@@ -202,14 +202,14 @@ async def update_coursechapters_meta(request: Request,course_id: str, coursechap
     courses = request.app.db["courses"]
 
     # update chapters in course
-    courseInDB = courses.update_one({"course_id": course_id}, {
+    courseInDB = await courses.update_one({"course_id": course_id}, {
                                     "$set": {"chapters": coursechapters_metadata.chapterOrder}})
 
     if coursechapters_metadata.chapters is not None:
         for coursechapter_id, chapter_metadata in coursechapters_metadata.chapters.items():
             filter_query = {"coursechapter_id": coursechapter_id}
             update_query = {"$set": {"lectures": chapter_metadata["lectureIds"]}}
-            result = coursechapters.update_one(filter_query, update_query)
+            result = await coursechapters.update_one(filter_query, update_query)
             if result.matched_count == 0:
                 # handle error when no documents are matched by the filter query
                 print(f"No documents found for course chapter ID {coursechapter_id}")
@@ -223,7 +223,7 @@ async def update_coursechapters_meta(request: Request,course_id: str, coursechap
 async def verify_rights(request: Request,course_id: str, current_user: PublicUser, action: str):
     courses = request.app.db["courses"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
 
     if not course:
         raise HTTPException(
diff --git a/src/services/courses/collections.py b/src/services/courses/collections.py
index 6c719819..3996c91b 100644
--- a/src/services/courses/collections.py
+++ b/src/services/courses/collections.py
@@ -30,7 +30,7 @@ class CollectionInDB(Collection):
 async def get_collection(request: Request,collection_id: str, current_user: PublicUser):
     collections = request.app.db["collections"]
 
-    collection = collections.find_one({"collection_id": collection_id})
+    collection = await collections.find_one({"collection_id": collection_id})
 
     # verify collection rights
     await verify_collection_rights(request, collection_id, current_user, "read")
@@ -47,7 +47,7 @@ async def create_collection(request: Request,collection_object: Collection, curr
     collections = request.app.db["collections"]
 
     # find if collection already exists using name
-    isCollectionNameAvailable = collections.find_one(
+    isCollectionNameAvailable = await collections.find_one(
         {"name": collection_object.name})
 
     # TODO
@@ -63,7 +63,7 @@ async def create_collection(request: Request,collection_object: Collection, curr
     collection = CollectionInDB(
         collection_id=collection_id, **collection_object.dict())
 
-    collection_in_db = collections.insert_one(collection.dict())
+    collection_in_db = await collections.insert_one(collection.dict())
 
     if not collection_in_db:
         raise HTTPException(
@@ -79,7 +79,7 @@ async def update_collection(request: Request,collection_object: Collection, coll
 
     collections = request.app.db["collections"]
 
-    collection = collections.find_one({"collection_id": collection_id})
+    collection = await collections.find_one({"collection_id": collection_id})
 
     if not collection:
         raise HTTPException(
@@ -88,7 +88,7 @@ async def update_collection(request: Request,collection_object: Collection, coll
     updated_collection = CollectionInDB(
         collection_id=collection_id,  **collection_object.dict())
 
-    collections.update_one({"collection_id": collection_id}, {
+    await collections.update_one({"collection_id": collection_id}, {
                            "$set": updated_collection.dict()})
 
     return Collection(**updated_collection.dict())
@@ -100,13 +100,13 @@ async def delete_collection(request: Request,collection_id: str, current_user: P
 
     collections = request.app.db["collections"]
 
-    collection = collections.find_one({"collection_id": collection_id})
+    collection = await collections.find_one({"collection_id": collection_id})
 
     if not collection:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="Collection does not exist")
 
-    isDeleted = collections.delete_one({"collection_id": collection_id})
+    isDeleted = await collections.delete_one({"collection_id": collection_id})
 
     if isDeleted:
         return {"detail": "collection deleted"}
@@ -129,7 +129,7 @@ async def get_collections(request: Request,page: int = 1, limit: int = 10):
 
     # create list of collections and include courses in each collection
     collections_list = []
-    for collection in all_collections:
+    for collection in await all_collections.to_list(length=100):
         collection = CollectionInDB(**collection)
         collections_list.append(collection)
 
@@ -140,7 +140,7 @@ async def get_collections(request: Request,page: int = 1, limit: int = 10):
         collection.courses = courses.find(
             {"course_id": {"$in": collection_courses}}, {'_id': 0})
 
-        collection.courses = [course for course in collection.courses]
+        collection.courses = [course for course in await collection.courses.to_list(length=100)]
 
     return collections_list
 
@@ -150,7 +150,7 @@ async def get_collections(request: Request,page: int = 1, limit: int = 10):
 async def verify_collection_rights(request: Request,collection_id: str,  current_user: PublicUser, action: str):
     collections = request.app.db["collections"]
 
-    collection = collections.find_one({"collection_id": collection_id})
+    collection = await collections.find_one({"collection_id": collection_id})
 
     if not collection and action != "create":
         raise HTTPException(
diff --git a/src/services/courses/courses.py b/src/services/courses/courses.py
index 52fdf9c4..265dcf85 100644
--- a/src/services/courses/courses.py
+++ b/src/services/courses/courses.py
@@ -56,7 +56,7 @@ class CourseChapterInDB(CourseChapter):
 async def get_course(request: Request, course_id: str, current_user: PublicUser):
     courses = request.app.db["courses"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
 
     # verify course rights
     await verify_rights(request, course_id, current_user, "read")
@@ -74,7 +74,7 @@ async def get_course_meta(request: Request, course_id: str, current_user: Public
     coursechapters = request.app.db["coursechapters"]
     activities = request.app.db["activities"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
     lectures = request.app.db["lectures"]
 
     # verify course rights
@@ -92,7 +92,7 @@ async def get_course_meta(request: Request, course_id: str, current_user: Public
 
     # chapters
     chapters = {}
-    for coursechapter in coursechapters:
+    for coursechapter in await coursechapters.to_list(length=100):
         coursechapter = CourseChapterInDB(**coursechapter)
         coursechapter_lectureIds = []
 
@@ -106,7 +106,7 @@ async def get_course_meta(request: Request, course_id: str, current_user: Public
 
     # lectures
     lectures_list = {}
-    for lecture in lectures.find({"lecture_id": {"$in": coursechapter_lectureIds_global}}):
+    for lecture in await lectures.find({"lecture_id": {"$in": coursechapter_lectureIds_global}}).to_list(length=100):
         lecture = LectureInDB(**lecture)
         lectures_list[lecture.lecture_id] = {
             "id": lecture.lecture_id, "name": lecture.name, "type": lecture.type, "content": lecture.content
@@ -119,7 +119,7 @@ async def get_course_meta(request: Request, course_id: str, current_user: Public
     course = Course(**course)
 
     # Get activity by user
-    activity = activities.find_one(
+    activity = await activities.find_one(
         {"course_id": course_id, "user_id": current_user.user_id})
     if activity:
         activity = json.loads(json.dumps(activity, default=str))
@@ -155,7 +155,7 @@ async def create_course(request: Request, course_object: Course, org_id: str, cu
     course = CourseInDB(course_id=course_id, authors=[
         current_user.user_id], creationDate=str(datetime.now()), updateDate=str(datetime.now()), **course_object.dict())
 
-    course_in_db = courses.insert_one(course.dict())
+    course_in_db = await courses.insert_one(course.dict())
 
     if not course_in_db:
         raise HTTPException(
@@ -171,7 +171,7 @@ async def update_course_thumbnail(request: Request, course_id: str, current_user
 
     courses = request.app.db["courses"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
     # TODO(fix) : the implementation here is clearly not the best one
     if course:
         creationDate = course["creationDate"]
@@ -184,7 +184,7 @@ async def update_course_thumbnail(request: Request, course_id: str, current_user
             updated_course = CourseInDB(course_id=course_id, creationDate=creationDate,
                                         authors=authors, updateDate=str(datetime.now()), **course.dict())
 
-            courses.update_one({"course_id": course_id}, {
+            await courses.update_one({"course_id": course_id}, {
                 "$set": updated_course.dict()})
 
             return CourseInDB(**updated_course.dict())
@@ -201,7 +201,7 @@ async def update_course(request: Request, course_object: Course, course_id: str,
 
     courses = request.app.db["courses"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
 
     if course:
         creationDate = course["creationDate"]
@@ -213,7 +213,7 @@ async def update_course(request: Request, course_object: Course, course_id: str,
         updated_course = CourseInDB(
             course_id=course_id, creationDate=creationDate, authors=authors, updateDate=str(datetime_object), **course_object.dict())
 
-        courses.update_one({"course_id": course_id}, {
+        await courses.update_one({"course_id": course_id}, {
             "$set": updated_course.dict()})
 
         return CourseInDB(**updated_course.dict())
@@ -230,13 +230,13 @@ async def delete_course(request: Request, course_id: str, current_user: PublicUs
 
     courses = request.app.db["courses"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
 
     if not course:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="Course does not exist")
 
-    isDeleted = courses.delete_one({"course_id": course_id})
+    isDeleted = await courses.delete_one({"course_id": course_id})
 
     if isDeleted:
         return {"detail": "Course deleted"}
@@ -256,7 +256,7 @@ async def get_courses(request: Request, page: int = 1, limit: int = 10, org_id:
     all_courses = courses.find({"org_id": org_id}).sort(
         "name", 1).skip(10 * (page - 1)).limit(limit)
 
-    return [json.loads(json.dumps(course, default=str)) for course in all_courses]
+    return [json.loads(json.dumps(course, default=str)) for course in await all_courses.to_list(length=100)]
 
 async def get_courses_orgslug(request: Request, page: int = 1, limit: int = 10, org_slug: str | None = None):
     courses = request.app.db["courses"]
@@ -264,7 +264,7 @@ async def get_courses_orgslug(request: Request, page: int = 1, limit: int = 10,
     # TODO : Get only courses that user is admin/has roles of
 
     # get org_id from slug
-    org = orgs.find_one({"slug": org_slug})
+    org = await orgs.find_one({"slug": org_slug})
 
     if not org:
         raise HTTPException(
@@ -274,7 +274,7 @@ async def get_courses_orgslug(request: Request, page: int = 1, limit: int = 10,
     all_courses = courses.find({"org_id": org['org_id']}).sort(
         "name", 1).skip(10 * (page - 1)).limit(limit)
 
-    return [json.loads(json.dumps(course, default=str)) for course in all_courses]
+    return [json.loads(json.dumps(course, default=str)) for course in await all_courses.to_list(length=100)]
 
 
 
@@ -284,7 +284,7 @@ async def get_courses_orgslug(request: Request, page: int = 1, limit: int = 10,
 async def verify_rights(request: Request, course_id: str, current_user: PublicUser, action: str):
     courses = request.app.db["courses"]
 
-    course = courses.find_one({"course_id": course_id})
+    course = await courses.find_one({"course_id": course_id})
 
     if not course:
         raise HTTPException(
diff --git a/src/services/courses/lectures/lectures.py b/src/services/courses/lectures/lectures.py
index ad43f8a8..51d58fb4 100644
--- a/src/services/courses/lectures/lectures.py
+++ b/src/services/courses/lectures/lectures.py
@@ -44,10 +44,10 @@ async def create_lecture(request: Request,lecture_object: Lecture, coursechapter
     # create lecture
     lecture = LectureInDB(**lecture_object.dict(), creationDate=str(
         datetime.now()), coursechapter_id=coursechapter_id, updateDate=str(datetime.now()), lecture_id=lecture_id)
-    lectures.insert_one(lecture.dict())
+    await lectures.insert_one(lecture.dict())
 
     # update chapter
-    coursechapters.update_one({"coursechapter_id": coursechapter_id}, {
+    await coursechapters.update_one({"coursechapter_id": coursechapter_id}, {
                        "$addToSet": {"lectures": lecture_id}})
 
     return lecture
@@ -56,7 +56,7 @@ async def create_lecture(request: Request,lecture_object: Lecture, coursechapter
 async def get_lecture(request: Request,lecture_id: str, current_user: PublicUser):
     lectures = request.app.db["lectures"]
 
-    lecture = lectures.find_one({"lecture_id": lecture_id})
+    lecture = await lectures.find_one({"lecture_id": lecture_id})
 
     # verify course rights
     hasRoleRights = await verify_user_rights_with_roles(request,"read", current_user.user_id, lecture_id)
@@ -80,7 +80,7 @@ async def update_lecture(request: Request,lecture_object: Lecture, lecture_id: s
 
     lectures = request.app.db["lectures"]
 
-    lecture = lectures.find_one({"lecture_id": lecture_id})
+    lecture = await lectures.find_one({"lecture_id": lecture_id})
 
     if lecture:
         creationDate = lecture["creationDate"]
@@ -91,7 +91,7 @@ async def update_lecture(request: Request,lecture_object: Lecture, lecture_id: s
         updated_course = LectureInDB(
             lecture_id=lecture_id, coursechapter_id=lecture["coursechapter_id"], creationDate=creationDate, updateDate=str(datetime_object), **lecture_object.dict())
 
-        lectures.update_one({"lecture_id": lecture_id}, {
+        await lectures.update_one({"lecture_id": lecture_id}, {
             "$set": updated_course.dict()})
 
         return LectureInDB(**updated_course.dict())
@@ -108,13 +108,13 @@ async def delete_lecture(request: Request,lecture_id: str, current_user: PublicU
 
     lectures = request.app.db["lectures"]
 
-    lecture = lectures.find_one({"lecture_id": lecture_id})
+    lecture = await lectures.find_one({"lecture_id": lecture_id})
 
     if not lecture:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="lecture does not exist")
 
-    isDeleted = lectures.delete_one({"lecture_id": lecture_id})
+    isDeleted = await lectures.delete_one({"lecture_id": lecture_id})
 
     if isDeleted:
         return {"detail": "lecture deleted"}
@@ -137,11 +137,8 @@ async def get_lectures(request: Request,coursechapter_id: str, current_user: Pub
 
     if not lectures:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="No lectures found")
+            status_code=status.HTTP_409_CONFLICT, detail="Course does not exist")
+    
+    lectures = [LectureInDB(**lecture) for lecture in await lectures.to_list(length=100)]
 
-    lectures_list = []
-
-    for lecture in lectures:
-        lectures_list.append(Lecture(**lecture))
-
-    return lectures_list
+    return lectures
diff --git a/src/services/courses/lectures/video.py b/src/services/courses/lectures/video.py
index de1d9821..b2c0dd0b 100644
--- a/src/services/courses/lectures/video.py
+++ b/src/services/courses/lectures/video.py
@@ -44,7 +44,7 @@ async def create_video_lecture(request: Request,name: str,  coursechapter_id: st
 
     # create lecture
     lecture = LectureInDB(**lecture_object.dict())
-    lectures.insert_one(lecture.dict())
+    await lectures.insert_one(lecture.dict())
 
     # upload video
     if video_file:
@@ -55,7 +55,7 @@ async def create_video_lecture(request: Request,name: str,  coursechapter_id: st
 
     # todo : choose whether to update the chapter or not
     # update chapter
-    coursechapters.update_one({"coursechapter_id": coursechapter_id}, {
+    await coursechapters.update_one({"coursechapter_id": coursechapter_id}, {
         "$addToSet": {"lectures": lecture_id}})
 
     return lecture
diff --git a/src/services/houses.py b/src/services/houses.py
index 75ebd90d..9acd1b96 100644
--- a/src/services/houses.py
+++ b/src/services/houses.py
@@ -131,7 +131,7 @@ async def get_houses(request: Request,page: int = 1, limit: int = 10):
     # get all houses from database
     all_houses = houses.find().sort("name", 1).skip(10 * (page - 1)).limit(limit)
 
-    return [json.loads(json.dumps(house, default=str)) for house in all_houses]
+    return [json.loads(json.dumps(house, default=str)) for house in await all_houses.to_list(length=limit)]
 
 
 #### Security ####################################################
diff --git a/src/services/mocks/initial.py b/src/services/mocks/initial.py
index ba8744b7..0e91f423 100644
--- a/src/services/mocks/initial.py
+++ b/src/services/mocks/initial.py
@@ -26,7 +26,7 @@ async def create_initial_data(request: Request):
     ########################################
 
     database_users = request.app.db["users"]
-    database_users.delete_many({})
+    await database_users.delete_many({})
 
     users = []
     admin_user = UserWithPassword(
@@ -53,7 +53,7 @@ async def create_initial_data(request: Request):
 
     # find admin user
     users = request.app.db["users"]
-    admin_user = users.find_one({"username": "admin"})
+    admin_user = await users.find_one({"username": "admin"})
 
     if admin_user:
         admin_user = UserInDB(**admin_user)
@@ -65,7 +65,7 @@ async def create_initial_data(request: Request):
     ########################################
 
     database_orgs = request.app.db["organizations"]
-    database_orgs.delete_many({})
+    await database_orgs.delete_many({})
 
     organizations = []
     for i in range(0, 5):
@@ -85,7 +85,7 @@ async def create_initial_data(request: Request):
     ########################################
 
     database_roles = request.app.db["roles"]
-    database_roles.delete_many({})
+    await database_roles.delete_many({})
 
     roles = []
     admin_role = Role(
@@ -117,14 +117,14 @@ async def create_initial_data(request: Request):
 
     database_courses = request.app.db["courses"]
     database_chapters = request.app.db["coursechapters"]
-    database_courses.delete_many({})
-    database_chapters.delete_many({})
+    await database_courses.delete_many({})
+    await database_chapters.delete_many({})
 
     courses = []
     orgs = request.app.db["organizations"]
 
-    if orgs.count_documents({}) > 0:
-        for org in orgs.find():
+    if await orgs.count_documents({}) > 0:
+        for org in await orgs.find().to_list(length=100):
             for i in range(0, 5):
 
                 # get image in BinaryIO format from unsplash and save it to disk
@@ -161,7 +161,7 @@ async def create_initial_data(request: Request):
                 course.thumbnail = name_in_disk
 
                 course = CourseInDB(**course.dict())
-                course_in_db = courses.insert_one(course.dict())
+                course_in_db = await courses.insert_one(course.dict())
 
                 # create chapters
                 for i in range(0, 5):
diff --git a/src/services/orgs.py b/src/services/orgs.py
index fe07f291..1e45853d 100644
--- a/src/services/orgs.py
+++ b/src/services/orgs.py
@@ -37,7 +37,7 @@ class PublicOrganization(Organization):
 async def get_organization(request: Request, org_id: str):
     orgs = request.app.db["organizations"]
 
-    org = orgs.find_one({"org_id": org_id})
+    org = await orgs.find_one({"org_id": org_id})
 
     if not org:
         raise HTTPException(
@@ -50,7 +50,7 @@ async def get_organization(request: Request, org_id: str):
 async def get_organization_by_slug(request: Request, org_slug: str):
     orgs = request.app.db["organizations"]
 
-    org = orgs.find_one({"slug": org_slug})
+    org = await orgs.find_one({"slug": org_slug})
 
     if not org:
         raise HTTPException(
@@ -64,7 +64,7 @@ async def create_org(request: Request, org_object: Organization, current_user: P
     orgs = request.app.db["organizations"]
 
     # find if org already exists using name
-    isOrgAvailable = orgs.find_one({"slug": org_object.slug})
+    isOrgAvailable = await orgs.find_one({"slug": org_object.slug})
 
     if isOrgAvailable:
         raise HTTPException(
@@ -77,7 +77,7 @@ async def create_org(request: Request, org_object: Organization, current_user: P
         current_user.user_id], admins=[
         current_user.user_id], **org_object.dict())
 
-    org_in_db = orgs.insert_one(org.dict())
+    org_in_db = await orgs.insert_one(org.dict())
 
     if not org_in_db:
         raise HTTPException(
@@ -93,7 +93,7 @@ async def update_org(request: Request, org_object: Organization, org_id: str, cu
 
     orgs = request.app.db["organizations"]
 
-    org = orgs.find_one({"org_id": org_id})
+    org = await orgs.find_one({"org_id": org_id})
 
     if org:
         owners = org["owners"]
@@ -106,7 +106,7 @@ async def update_org(request: Request, org_object: Organization, org_id: str, cu
     updated_org = OrganizationInDB(
         org_id=org_id, owners=owners, admins=admins, **org_object.dict())
 
-    orgs.update_one({"org_id": org_id}, {"$set": updated_org.dict()})
+    await orgs.update_one({"org_id": org_id}, {"$set": updated_org.dict()})
 
     return Organization(**updated_org.dict())
 
@@ -117,13 +117,13 @@ async def delete_org(request: Request, org_id: str, current_user: PublicUser):
 
     orgs = request.app.db["organizations"]
 
-    org = orgs.find_one({"org_id": org_id})
+    org = await orgs.find_one({"org_id": org_id})
 
     if not org:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="Organization does not exist")
 
-    isDeleted = orgs.delete_one({"org_id": org_id})
+    isDeleted = await orgs.delete_one({"org_id": org_id})
 
     if isDeleted:
         return {"detail": "Org deleted"}
@@ -137,9 +137,9 @@ async def get_orgs_by_user(request: Request, user_id: str, page: int = 1, limit:
 
     # find all orgs where user_id is in owners or admins arrays
     all_orgs = orgs.find({"$or": [{"owners": user_id}, {"admins": user_id}]}).sort(
-        "name", 1).skip(10 * (page - 1)).limit(limit)
+        "name", 1).skip(10 * (page - 1)).limit(100)
 
-    return [json.loads(json.dumps(org, default=str)) for org in all_orgs]
+    return [json.loads(json.dumps(org, default=str)) for org in await all_orgs.to_list(length=100)]
 
 
 #### Security ####################################################
@@ -147,7 +147,7 @@ async def get_orgs_by_user(request: Request, user_id: str, page: int = 1, limit:
 async def verify_org_rights(request: Request, org_id: str,  current_user: PublicUser, action: str,):
     orgs = request.app.db["organizations"]
 
-    org = orgs.find_one({"org_id": org_id})
+    org = await orgs.find_one({"org_id": org_id})
 
     if not org:
         raise HTTPException(
diff --git a/src/services/roles.py b/src/services/roles.py
index 53642002..eb170627 100644
--- a/src/services/roles.py
+++ b/src/services/roles.py
@@ -47,7 +47,7 @@ class RoleInDB(Role):
 async def get_role(request: Request,role_id: str):
     roles = request.app.db["roles"]
 
-    role = roles.find_one({"role_id": role_id})
+    role = await roles.find_one({"role_id": role_id})
 
     if not role:
         raise HTTPException(
@@ -61,7 +61,7 @@ async def create_role(request: Request,role_object: Role, current_user: PublicUs
     roles = request.app.db["roles"]
 
     # find if house already exists using name
-    isRoleAvailable = roles.find_one({"name": role_object.name})
+    isRoleAvailable = await roles.find_one({"name": role_object.name})
 
     if isRoleAvailable:
         raise HTTPException(
@@ -75,7 +75,7 @@ async def create_role(request: Request,role_object: Role, current_user: PublicUs
     role = RoleInDB(role_id=role_id, creationDate=str(datetime.now()),
                     updateDate=str(datetime.now()), **role_object.dict())
 
-    role_in_db = roles.insert_one(role.dict())
+    role_in_db = await roles.insert_one(role.dict())
 
     if not role_in_db:
         raise HTTPException(
@@ -91,7 +91,7 @@ async def update_role(request: Request,role_object: Role, role_id: str, current_
 
     roles = request.app.db["roles"]
 
-    role = roles.find_one({"role_id": role_id})
+    role = await roles.find_one({"role_id": role_id})
 
     if not role:
         raise HTTPException(
@@ -100,7 +100,7 @@ async def update_role(request: Request,role_object: Role, role_id: str, current_
     updated_role = RoleInDB(
         role_id=role_id, updateDate=str(datetime.now()), creationDate=role["creationDate"],  **role_object.dict())
 
-    roles.update_one({"role_id": role_id}, {"$set": updated_role.dict()})
+    await roles.update_one({"role_id": role_id}, {"$set": updated_role.dict()})
 
     return RoleInDB(**updated_role.dict())
 
@@ -112,13 +112,13 @@ async def delete_role(request: Request,role_id: str, current_user: PublicUser):
 
     roles = request.app.db["roles"]
 
-    role = roles.find_one({"role_id": role_id})
+    role = await roles.find_one({"role_id": role_id})
 
     if not role:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="Role does not exist")
 
-    isDeleted = roles.delete_one({"role_id": role_id})
+    isDeleted = await roles.delete_one({"role_id": role_id})
 
     if isDeleted:
         return {"detail": "Role deleted"}
@@ -133,7 +133,7 @@ async def get_roles(request: Request,page: int = 1, limit: int = 10):
     # get all roles from database
     all_roles = roles.find().sort("name", 1).skip(10 * (page - 1)).limit(limit)
 
-    return [json.loads(json.dumps(role, default=str)) for role in all_roles]
+    return [json.loads(json.dumps(role, default=str)) for role in await all_roles.to_list(length=limit)]
 
 
 #### Security ####################################################
@@ -141,7 +141,7 @@ async def get_roles(request: Request,page: int = 1, limit: int = 10):
 async def verify_user_permissions_on_roles(request: Request,action: str, current_user: PublicUser):
     users = request.app.db["users"]
 
-    user = users.find_one({"user_id": current_user.user_id})
+    user = await users.find_one({"user_id": current_user.user_id})
 
     if not user:
         raise HTTPException(
diff --git a/src/services/security.py b/src/services/security.py
index c9ae871b..57b9583b 100644
--- a/src/services/security.py
+++ b/src/services/security.py
@@ -42,7 +42,7 @@ async def verify_user_rights_with_roles(request: Request,action: str, user_id: s
 
     # Info: permission actions are: read, create, delete, update
 
-    for role in user_roles_cursor:
+    for role in await user_roles_cursor.to_list(length=100):
         user_roles.append(role)
 
     for role in user_roles:
diff --git a/src/services/users.py b/src/services/users.py
index 57f2829e..36bc8fe6 100644
--- a/src/services/users.py
+++ b/src/services/users.py
@@ -57,7 +57,7 @@ class Role(BaseModel):
 async def get_user(request: Request, username: str):
     users = request.app.db["users"]
 
-    user = users.find_one({"username": username})
+    user = await users.find_one({"username": username})
 
     if not user:
         raise HTTPException(
@@ -71,7 +71,7 @@ async def get_profile_metadata(request: Request, user):
     users = request.app.db["users"]
     roles = request.app.db["roles"]
 
-    user = users.find_one({"user_id": user['user_id']})
+    user = await users.find_one({"user_id": user['user_id']})
 
     if not user:
         raise HTTPException(
@@ -81,7 +81,7 @@ async def get_profile_metadata(request: Request, user):
     user_roles = roles.find({"linked_users": user['user_id']})
 
     user_roles_list = []
-    for role in user_roles:
+    for role in await user_roles.to_list(length=100):
         print(role)
         user_roles_list.append(Role(**role))
 
@@ -94,7 +94,7 @@ async def get_profile_metadata(request: Request, user):
 async def get_user_by_userid(request: Request, user_id: str):
     users = request.app.db["users"]
 
-    user = users.find_one({"user_id": user_id})
+    user = await users.find_one({"user_id": user_id})
 
     if not user:
         raise HTTPException(
@@ -107,7 +107,7 @@ async def get_user_by_userid(request: Request, user_id: str):
 async def security_get_user(request: Request, email: str):
     users = request.app.db["users"]
 
-    user = users.find_one({"email": email})
+    user = await users.find_one({"email": email})
 
     if not user:
         raise HTTPException(
@@ -119,7 +119,7 @@ async def security_get_user(request: Request, email: str):
 async def get_userid_by_username(request: Request, username: str):
     users = request.app.db["users"]
 
-    user = users.find_one({"username": username})
+    user = await users.find_one({"username": username})
 
     if not user:
         raise HTTPException(
@@ -131,8 +131,8 @@ async def get_userid_by_username(request: Request, username: str):
 async def update_user(request: Request, user_id: str, user_object: UserWithPassword):
     users = request.app.db["users"]
 
-    isUserExists = users.find_one({"user_id": user_id})
-    isUsernameAvailable = users.find_one({"username": user_object.username})
+    isUserExists = await users.find_one({"user_id": user_id})
+    isUsernameAvailable = await users.find_one({"username": user_object.username})
 
     if not isUserExists:
         raise HTTPException(
@@ -153,7 +153,7 @@ async def update_user(request: Request, user_id: str, user_object: UserWithPassw
 async def delete_user(request: Request, user_id: str):
     users = request.app.db["users"]
 
-    isUserAvailable = users.find_one({"user_id": user_id})
+    isUserAvailable = await users.find_one({"user_id": user_id})
 
     if not isUserAvailable:
         raise HTTPException(
@@ -167,7 +167,7 @@ async def delete_user(request: Request, user_id: str):
 async def create_user(request: Request, user_object: UserWithPassword):
     users = request.app.db["users"]
 
-    isUserAvailable = users.find_one({"username": user_object.username})
+    isUserAvailable = await users.find_one({"username": user_object.username})
 
     if isUserAvailable:
         raise HTTPException(
@@ -184,6 +184,6 @@ async def create_user(request: Request, user_object: UserWithPassword):
     user = UserInDB(user_id=user_id, creationDate=str(datetime.now()),
                     updateDate=str(datetime.now()), **user_object.dict())
 
-    user_in_db = users.insert_one(user.dict())
+    user_in_db = await users.insert_one(user.dict())
 
     return User(**user.dict())