diff --git a/videodb/_constants.py b/videodb/_constants.py
index 9acfa22..173c825 100644
--- a/videodb/_constants.py
+++ b/videodb/_constants.py
@@ -1,4 +1,5 @@
 """Constants used in the videodb package."""
+
 from typing import Union
 from dataclasses import dataclass
 
diff --git a/videodb/audio.py b/videodb/audio.py
index 1e2df60..21c250c 100644
--- a/videodb/audio.py
+++ b/videodb/audio.py
@@ -4,7 +4,17 @@
 
 
 class Audio:
-    def __init__(self, _connection, id: str, collection_id: str, **kwargs) -> None:
+    """Audio class to interact with the Audio
+
+    :ivar str id: Unique identifier for the audio
+    :ivar str collection_id: ID of the collection this audio belongs to
+    :ivar str name: Name of the audio file
+    :ivar float length: Duration of the audio in seconds
+    """
+
+    def __init__(
+        self, _connection, id: str, collection_id: str, **kwargs
+    ) -> None:
         self._connection = _connection
         self.id = id
         self.collection_id = collection_id
@@ -21,6 +31,12 @@ def __repr__(self) -> str:
         )
 
     def generate_url(self) -> str:
+        """Generate the signed url of the audio.
+
+        :raises InvalidRequestError: If the get_url fails
+        :return: The signed url of the audio
+        :rtype: str
+        """
         url_data = self._connection.post(
             path=f"{ApiPath.audio}/{self.id}/{ApiPath.generate_url}",
             params={"collection_id": self.collection_id},
@@ -28,4 +44,10 @@ def generate_url(self) -> str:
         return url_data.get("signed_url", None)
 
     def delete(self) -> None:
+        """Delete the audio.
+
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         self._connection.delete(f"{ApiPath.audio}/{self.id}")
diff --git a/videodb/client.py b/videodb/client.py
index 3fbee06..f47df97 100644
--- a/videodb/client.py
+++ b/videodb/client.py
@@ -24,13 +24,32 @@
 
 
 class Connection(HttpClient):
-    def __init__(self, api_key: str, base_url: str) -> None:
+    """Connection class to interact with the VideoDB"""
+
+    def __init__(self, api_key: str, base_url: str) -> "Connection":
+        """Initializes a new instance of the Connection class with specified API credentials.
+
+        Note: Users should not initialize this class directly.
+        Instead use :meth:`videodb.connect() <videodb.connect>`
+
+        :param str api_key: API key for authentication
+        :param str base_url: Base URL of the VideoDB API
+        :raise ValueError: If the API key is not provided
+        :return: :class:`Connection <Connection>` object, to interact with the VideoDB
+        :rtype: :class:`videodb.client.Connection`
+        """
         self.api_key = api_key
         self.base_url = base_url
         self.collection_id = "default"
         super().__init__(api_key=api_key, base_url=base_url, version=__version__)
 
     def get_collection(self, collection_id: Optional[str] = "default") -> Collection:
+        """Get a collection object by its ID.
+
+        :param str collection_id: ID of the collection (optional, default: "default")
+        :return: :class:`Collection <Collection>` object
+        :rtype: :class:`videodb.collection.Collection`
+        """
         collection_data = self.get(path=f"{ApiPath.collection}/{collection_id}")
         self.collection_id = collection_data.get("id", "default")
         return Collection(
@@ -42,6 +61,11 @@ def get_collection(self, collection_id: Optional[str] = "default") -> Collection
         )
 
     def get_collections(self) -> List[Collection]:
+        """Get a list of all collections.
+
+        :return: List of :class:`Collection <Collection>` objects
+        :rtype: list[:class:`videodb.collection.Collection`]
+        """
         collections_data = self.get(path=ApiPath.collection)
         return [
             Collection(
@@ -57,6 +81,14 @@ def get_collections(self) -> List[Collection]:
     def create_collection(
         self, name: str, description: str, is_public: bool = False
     ) -> Collection:
+        """Create a new collection.
+
+        :param str name: Name of the collection
+        :param str description: Description of the collection
+        :param bool is_public: Make collection public (optional, default: False)
+        :return: :class:`Collection <Collection>` object
+        :rtype: :class:`videodb.collection.Collection`
+        """
         collection_data = self.post(
             path=ApiPath.collection,
             data={
@@ -75,6 +107,14 @@ def create_collection(
         )
 
     def update_collection(self, id: str, name: str, description: str) -> Collection:
+        """Update an existing collection.
+
+        :param str id: ID of the collection
+        :param str name: Name of the collection 
+        :param str description: Description of the collection
+        :return: :class:`Collection <Collection>` object
+        :rtype: :class:`videodb.collection.Collection`
+        """
         collection_data = self.patch(
             path=f"{ApiPath.collection}/{id}",
             data={
@@ -92,12 +132,29 @@ def update_collection(self, id: str, name: str, description: str) -> Collection:
         )
 
     def check_usage(self) -> dict:
+        """Check the usage.
+
+        :return: Usage data
+        :rtype: dict
+        """
         return self.get(path=f"{ApiPath.billing}/{ApiPath.usage}")
 
     def get_invoices(self) -> List[dict]:
+        """Get a list of all invoices.
+
+        :return: List of invoices
+        :rtype: list[dict]
+        """
         return self.get(path=f"{ApiPath.billing}/{ApiPath.invoices}")
 
     def download(self, stream_link: str, name: str) -> dict:
+        """Download a file from a stream link.
+
+        :param stream_link: URL of the stream to download
+        :param name: Name to save the downloaded file as
+        :return: Download response data
+        :rtype: dict
+        """
         return self.post(
             path=f"{ApiPath.download}",
             data={
@@ -115,6 +172,17 @@ def upload(
         description: Optional[str] = None,
         callback_url: Optional[str] = None,
     ) -> Union[Video, Audio, Image, None]:
+        """Upload a file.
+
+        :param str file_path: Path to the file to upload (optional)
+        :param str url: URL of the file to upload (optional)
+        :param MediaType media_type: MediaType object (optional)
+        :param str name: Name of the file (optional)
+        :param str description: Description of the file (optional)
+        :param str callback_url: URL to receive the callback (optional)
+        :return: :class:`Video <Video>`, or :class:`Audio <Audio>`, or :class:`Image <Image>` object
+        :rtype: Union[ :class:`videodb.video.Video`, :class:`videodb.audio.Audio`, :class:`videodb.image.Image`]
+        """
         upload_data = upload(
             self,
             file_path,
diff --git a/videodb/collection.py b/videodb/collection.py
index 96512cd..756ab5d 100644
--- a/videodb/collection.py
+++ b/videodb/collection.py
@@ -24,6 +24,12 @@
 
 
 class Collection:
+    """Collection class to interact with the Collection.
+
+    Note: Users should not initialize this class directly.
+    Instead use :meth:`Connection.get_collection() <videodb.client.Connection.get_collection>`
+    """
+
     def __init__(
         self,
         _connection,
@@ -57,6 +63,11 @@ def delete(self) -> None:
         self._connection.delete(path=f"{ApiPath.collection}/{self.id}")
 
     def get_videos(self) -> List[Video]:
+        """Get all the videos in the collection.
+
+        :return: List of :class:`Video <Video>` objects
+        :rtype: List[:class:`videodb.video.Video`]
+        """
         videos_data = self._connection.get(
             path=f"{ApiPath.video}",
             params={"collection_id": self.id},
@@ -64,13 +75,19 @@ def get_videos(self) -> List[Video]:
         return [Video(self._connection, **video) for video in videos_data.get("videos")]
 
     def get_video(self, video_id: str) -> Video:
+        """Get a video by its ID.
+
+        :param str video_id: ID of the video
+        :return: :class:`Video <Video>` object
+        :rtype: :class:`videodb.video.Video`
+        """
         video_data = self._connection.get(
             path=f"{ApiPath.video}/{video_id}", params={"collection_id": self.id}
         )
         return Video(self._connection, **video_data)
 
     def delete_video(self, video_id: str) -> None:
-        """Delete the video
+        """Delete the video.
 
         :param str video_id: The id of the video to be deleted
         :raises InvalidRequestError: If the delete fails
@@ -82,6 +99,11 @@ def delete_video(self, video_id: str) -> None:
         )
 
     def get_audios(self) -> List[Audio]:
+        """Get all the audios in the collection.
+
+        :return: List of :class:`Audio <Audio>` objects
+        :rtype: List[:class:`videodb.audio.Audio`]
+        """
         audios_data = self._connection.get(
             path=f"{ApiPath.audio}",
             params={"collection_id": self.id},
@@ -89,17 +111,35 @@ def get_audios(self) -> List[Audio]:
         return [Audio(self._connection, **audio) for audio in audios_data.get("audios")]
 
     def get_audio(self, audio_id: str) -> Audio:
+        """Get an audio by its ID.
+
+        :param str audio_id: ID of the audio
+        :return: :class:`Audio <Audio>` object
+        :rtype: :class:`videodb.audio.Audio`
+        """
         audio_data = self._connection.get(
             path=f"{ApiPath.audio}/{audio_id}", params={"collection_id": self.id}
         )
         return Audio(self._connection, **audio_data)
 
     def delete_audio(self, audio_id: str) -> None:
+        """Delete the audio.
+
+        :param str audio_id: The id of the audio to be deleted
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         return self._connection.delete(
             path=f"{ApiPath.audio}/{audio_id}", params={"collection_id": self.id}
         )
 
     def get_images(self) -> List[Image]:
+        """Get all the images in the collection.
+
+        :return: List of :class:`Image <Image>` objects
+        :rtype: List[:class:`videodb.image.Image`]
+        """
         images_data = self._connection.get(
             path=f"{ApiPath.image}",
             params={"collection_id": self.id},
@@ -107,12 +147,25 @@ def get_images(self) -> List[Image]:
         return [Image(self._connection, **image) for image in images_data.get("images")]
 
     def get_image(self, image_id: str) -> Image:
+        """Get an image by its ID.
+
+        :param str image_id: ID of the image
+        :return: :class:`Image <Image>` object
+        :rtype: :class:`videodb.image.Image`
+        """
         image_data = self._connection.get(
             path=f"{ApiPath.image}/{image_id}", params={"collection_id": self.id}
         )
         return Image(self._connection, **image_data)
 
     def delete_image(self, image_id: str) -> None:
+        """Delete the image.
+
+        :param str image_id: The id of the image to be deleted
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         return self._connection.delete(
             path=f"{ApiPath.image}/{image_id}", params={"collection_id": self.id}
         )
@@ -127,6 +180,18 @@ def search(
         dynamic_score_percentage: Optional[float] = None,
         filter: List[Dict[str, Any]] = [],
     ) -> SearchResult:
+        """Search for a query in the collection.
+
+        :param str query: Query to search for
+        :param SearchType search_type: Type of search to perform (optional)
+        :param IndexType index_type: Type of index to search (optional)
+        :param int result_threshold: Number of results to return (optional)
+        :param float score_threshold: Threshold score for the search (optional)
+        :param float dynamic_score_percentage: Percentage of dynamic score to consider (optional)
+        :raise SearchError: If the search fails
+        :return: :class:`SearchResult <SearchResult>` object
+        :rtype: :class:`videodb.search.SearchResult`
+        """
         search = SearchFactory(self._connection).get_search(search_type)
         return search.search_inside_collection(
             collection_id=self.id,
@@ -161,6 +226,17 @@ def upload(
         description: Optional[str] = None,
         callback_url: Optional[str] = None,
     ) -> Union[Video, Audio, Image, None]:
+        """Upload a file to the collection.
+
+        :param str file_path: Path to the file to be uploaded
+        :param str url: URL of the file to be uploaded
+        :param MediaType media_type: MediaType object (optional)
+        :param str name: Name of the file (optional)
+        :param str description: Description of the file (optional)
+        :param str callback_url: URL to receive the callback (optional)
+        :return: :class:`Video <Video>`, or :class:`Audio <Audio>`, or :class:`Image <Image>` object
+        :rtype: Union[ :class:`videodb.video.Video`, :class:`videodb.audio.Audio`, :class:`videodb.image.Image`]
+        """
         upload_data = upload(
             self._connection,
             file_path,
@@ -179,12 +255,22 @@ def upload(
             return Image(self._connection, **upload_data)
 
     def make_public(self):
+        """Make the collection public.
+
+        :return: None
+        :rtype: None
+        """
         self._connection.patch(
             path=f"{ApiPath.collection}/{self.id}", data={"is_public": True}
         )
         self.is_public = True
 
     def make_private(self):
+        """Make the collection private.
+
+        :return: None
+        :rtype: None
+        """
         self._connection.patch(
             path=f"{ApiPath.collection}/{self.id}", data={"is_public": False}
         )
diff --git a/videodb/image.py b/videodb/image.py
index 5aa1acf..8216eb1 100644
--- a/videodb/image.py
+++ b/videodb/image.py
@@ -4,6 +4,14 @@
 
 
 class Image:
+    """Image class to interact with the Image
+
+    :ivar str id: Unique identifier for the image
+    :ivar str collection_id: ID of the collection this image belongs to 
+    :ivar str name: Name of the image file
+    :ivar str url: URL of the image
+    """
+
     def __init__(self, _connection, id: str, collection_id: str, **kwargs) -> None:
         self._connection = _connection
         self.id = id
@@ -21,6 +29,12 @@ def __repr__(self) -> str:
         )
 
     def generate_url(self) -> str:
+        """Generate the signed url of the image.
+
+        :raises InvalidRequestError: If the get_url fails
+        :return: The signed url of the image
+        :rtype: str
+        """
         url_data = self._connection.post(
             path=f"{ApiPath.image}/{self.id}/{ApiPath.generate_url}",
             params={"collection_id": self.collection_id},
@@ -28,10 +42,26 @@ def generate_url(self) -> str:
         return url_data.get("signed_url", None)
 
     def delete(self) -> None:
+        """Delete the image.
+
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         self._connection.delete(f"{ApiPath.image}/{self.id}")
 
 
 class Frame(Image):
+    """Frame class to interact with video frames
+
+    :ivar str id: Unique identifier for the frame
+    :ivar str video_id: ID of the video this frame belongs to
+    :ivar str scene_id: ID of the scene this frame belongs to
+    :ivar str url: URL of the frame
+    :ivar float frame_time: Timestamp of the frame in the video
+    :ivar str description: Description of the frame contents
+    """
+
     def __init__(
         self,
         _connection,
@@ -70,6 +100,13 @@ def to_json(self):
         }
 
     def describe(self, prompt: str = None, model_name=None):
+        """Describe the frame.
+
+        :param str prompt: (optional) The prompt to use for the description
+        :param str model_name: (optional) The model to use for the description
+        :return: The description of the frame
+        :rtype: str
+        """
         description_data = self._connection.post(
             path=f"{ApiPath.video}/{self.video_id}/{ApiPath.frame}/{self.id}/{ApiPath.describe}",
             data={"prompt": prompt, "model_name": model_name},
diff --git a/videodb/scene.py b/videodb/scene.py
index ebc1cf0..41ef669 100644
--- a/videodb/scene.py
+++ b/videodb/scene.py
@@ -6,6 +6,16 @@
 
 
 class Scene:
+    """Scene class to interact with video scenes
+
+    :ivar str id: Unique identifier for the scene
+    :ivar str video_id: ID of the video this scene belongs to 
+    :ivar float start: Start time of the scene in seconds
+    :ivar float end: End time of the scene in seconds
+    :ivar List[Frame] frames: List of frames in the scene
+    :ivar str description: Description of the scene contents
+    """
+
     def __init__(
         self,
         video_id: str,
@@ -50,6 +60,13 @@ def to_json(self):
         }
 
     def describe(self, prompt: str = None, model_name=None) -> None:
+        """Describe the scene.
+
+        :param str prompt: (optional) The prompt to use for the description
+        :param str model_name: (optional) The model to use for the description
+        :return: The description of the scene
+        :rtype: str
+        """
         if self._connection is None:
             raise ValueError("Connection is required to describe a scene")
         description_data = self._connection.post(
@@ -61,6 +78,14 @@ def describe(self, prompt: str = None, model_name=None) -> None:
 
 
 class SceneCollection:
+    """SceneCollection class to interact with collections of scenes
+
+    :ivar str id: Unique identifier for the scene collection
+    :ivar str video_id: ID of the video these scenes belong to
+    :ivar dict config: Configuration settings for the scene collection
+    :ivar List[Scene] scenes: List of scenes in the collection
+    """
+
     def __init__(
         self,
         _connection,
@@ -85,6 +110,12 @@ def __repr__(self) -> str:
         )
 
     def delete(self) -> None:
+        """Delete the scene collection.
+
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         self._connection.delete(
             path=f"{ApiPath.video}/{self.video_id}/{ApiPath.scenes}/{self.id}"
         )
diff --git a/videodb/search.py b/videodb/search.py
index bef8fe2..ba557be 100644
--- a/videodb/search.py
+++ b/videodb/search.py
@@ -14,6 +14,14 @@
 
 
 class SearchResult:
+    """SearchResult class to interact with search results
+
+    :ivar str collection_id: ID of the collection this search result belongs to
+    :ivar str stream_url: URL to stream the search result
+    :ivar str player_url: URL to play the search result in a player
+    :ivar list[Shot] shots: List of shots in the search result
+    """
+
     def __init__(self, _connection, **kwargs):
         self._connection = _connection
         self.shots = []
@@ -53,7 +61,7 @@ def get_shots(self) -> List[Shot]:
         return self.shots
 
     def compile(self) -> str:
-        """Compile the search result shots into a stream url
+        """Compile the search result shots into a stream url.
 
         :raises SearchError: If no shots are found in the search results
         :return: The stream url
@@ -81,7 +89,7 @@ def compile(self) -> str:
             raise SearchError("No shots found in search results to compile")
 
     def play(self) -> str:
-        """Generate a stream url for the shot and open it in the default browser
+        """Generate a stream url for the shot and open it in the default browser.
 
         :return: The stream url
         :rtype: str
diff --git a/videodb/shot.py b/videodb/shot.py
index d715de0..c2fadcb 100644
--- a/videodb/shot.py
+++ b/videodb/shot.py
@@ -1,4 +1,3 @@
-"""This module contains the shot class"""
 
 
 from typing import Optional
@@ -9,7 +8,18 @@
 
 
 class Shot:
-    """A shot is a part of a video that contains a specific scene"""
+    """Shot class to interact with video shots
+
+    :ivar str video_id: Unique identifier for the video
+    :ivar float video_length: Duration of the video in seconds
+    :ivar str video_title: Title of the video
+    :ivar float start: Start time of the shot in seconds
+    :ivar float end: End time of the shot in seconds
+    :ivar str text: Text content of the shot
+    :ivar int search_score: Search relevance score
+    :ivar str stream_url: URL to stream the shot
+    :ivar str player_url: URL to play the shot in a player
+    """
 
     def __init__(
         self,
@@ -51,7 +61,7 @@ def __getitem__(self, key):
         return self.__dict__[key]
 
     def generate_stream(self) -> str:
-        """Generate a stream url for the shot
+        """Generate a stream url for the shot.
 
         :return: The stream url
         :rtype: str
@@ -72,7 +82,7 @@ def generate_stream(self) -> str:
             return self.stream_url
 
     def play(self) -> str:
-        """Generate a stream url for the shot and open it in the default browser/ notebook
+        """Generate a stream url for the shot and open it in the default browser/ notebook.
 
         :return: The stream url
         :rtype: str
diff --git a/videodb/timeline.py b/videodb/timeline.py
index c4b63ce..f1d1887 100644
--- a/videodb/timeline.py
+++ b/videodb/timeline.py
@@ -24,6 +24,13 @@ def to_json(self) -> dict:
         return {"timeline": timeline_json}
 
     def add_inline(self, asset: VideoAsset) -> None:
+        """Add a video asset to the timeline
+
+        :param VideoAsset asset: The video asset to add, :class:`VideoAsset` <VideoAsset> object
+        :raises ValueError: If asset is not of type :class:`VideoAsset` <VideoAsset>
+        :return: None
+        :rtype: None
+        """
         if not isinstance(asset, VideoAsset):
             raise ValueError("asset must be of type VideoAsset")
         self._timeline.append(asset)
@@ -31,6 +38,13 @@ def add_inline(self, asset: VideoAsset) -> None:
     def add_overlay(
         self, start: int, asset: Union[AudioAsset, ImageAsset, TextAsset]
     ) -> None:
+        """Add an overlay asset to the timeline
+
+        :param int start: The start time of the overlay asset
+        :param Union[AudioAsset, ImageAsset, TextAsset] asset: The overlay asset to add, :class:`AudioAsset <AudioAsset>`, :class:`ImageAsset <ImageAsset>`, :class:`TextAsset <TextAsset>` object
+        :return: None
+        :rtype: None
+        """
         if (
             not isinstance(asset, AudioAsset)
             and not isinstance(asset, ImageAsset)
@@ -42,6 +56,11 @@ def add_overlay(
         self._timeline.append((start, asset))
 
     def generate_stream(self) -> str:
+        """Generate a stream url for the timeline
+
+        :return: The stream url
+        :rtype: str
+        """
         stream_data = self._connection.post(
             path=f"{ApiPath.timeline}",
             data={
diff --git a/videodb/video.py b/videodb/video.py
index 0e8dd98..f72e1a1 100644
--- a/videodb/video.py
+++ b/videodb/video.py
@@ -16,6 +16,21 @@
 
 
 class Video:
+    """Video class to interact with the Video
+
+    :ivar str id: Unique identifier for the video
+    :ivar str collection_id: ID of the collection this video belongs to
+    :ivar str stream_url: URL to stream the video
+    :ivar str player_url: URL to play the video in a player
+    :ivar str name: Name of the video file
+    :ivar str description: Description of the video
+    :ivar str thumbnail_url: URL of the video thumbnail
+    :ivar float length: Duration of the video in seconds
+    :ivar list transcript: Timestamped transcript segments
+    :ivar str transcript_text: Full transcript text
+    :ivar list scenes: List of scenes in the video
+    """
+
     def __init__(self, _connection, id: str, collection_id: str, **kwargs) -> None:
         self._connection = _connection
         self.id = id
@@ -57,6 +72,18 @@ def search(
         filter: List[Dict[str, Any]] = [],
         **kwargs,
     ) -> SearchResult:
+        """Search for a query in the video.
+
+        :param str query: Query to search for.
+        :param SearchType search_type: (optional) Type of search to perform :class:`SearchType <SearchType>` object
+        :param IndexType index_type: (optional) Type of index to search :class:`IndexType <IndexType>` object
+        :param int result_threshold: (optional) Number of results to return
+        :param float score_threshold: (optional) Threshold score for the search
+        :param float dynamic_score_percentage: (optional) Percentage of dynamic score to consider
+        :raise SearchError: If the search fails
+        :return: :class:`SearchResult <SearchResult>` object
+        :rtype: :class:`videodb.search.SearchResult`
+        """
         search = SearchFactory(self._connection).get_search(search_type)
         return search.search_inside_video(
             video_id=self.id,
@@ -71,7 +98,7 @@ def search(
         )
 
     def delete(self) -> None:
-        """Delete the video
+        """Delete the video.
 
         :raises InvalidRequestError: If the delete fails
         :return: None if the delete is successful
@@ -80,12 +107,20 @@ def delete(self) -> None:
         self._connection.delete(path=f"{ApiPath.video}/{self.id}")
 
     def remove_storage(self) -> None:
+        """Remove the video storage.
+
+        :raises InvalidRequestError: If the storage removal fails
+        :return: None if the removal is successful
+        :rtype: None
+        """
         self._connection.delete(path=f"{ApiPath.video}/{self.id}/{ApiPath.storage}")
 
-    def generate_stream(self, timeline: Optional[List[Tuple[int, int]]] = None) -> str:
-        """Generate the stream url of the video
+    def generate_stream(
+        self, timeline: Optional[List[Tuple[float, float]]] = None
+    ) -> str:
+        """Generate the stream url of the video.
 
-        :param list timeline: The timeline of the video to be streamed. Defaults to None.
+        :param List[Tuple[float, float]] timeline: (optional) The timeline of the video to be streamed in the format [(start, end)]
         :raises InvalidRequestError: If the get_stream fails
         :return: The stream url of the video
         :rtype: str
@@ -103,6 +138,12 @@ def generate_stream(self, timeline: Optional[List[Tuple[int, int]]] = None) -> s
         return stream_data.get("stream_url", None)
 
     def generate_thumbnail(self, time: Optional[float] = None) -> Union[str, Image]:
+        """Generate the thumbnail of the video.
+
+        :param float time: (optional) The time of the video to generate the thumbnail
+        :returns: :class:`Image <Image>` object if time is provided else the thumbnail url
+        :rtype: Union[str, :class:`videodb.image.Image`]
+        """
         if self.thumbnail_url and not time:
             return self.thumbnail_url
 
@@ -122,6 +163,11 @@ def generate_thumbnail(self, time: Optional[float] = None) -> Union[str, Image]:
         return self.thumbnail_url
 
     def get_thumbnails(self) -> List[Image]:
+        """Get all the thumbnails of the video.
+
+        :return: List of :class:`Image <Image>` objects
+        :rtype: List[:class:`videodb.image.Image`]
+        """
         thumbnails_data = self._connection.get(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.thumbnails}"
         )
@@ -162,10 +208,21 @@ def get_transcript(
         self,
         start: int = None,
         end: int = None,
-        segmenter: str = Segmenter.word,
+        segmenter: Segmenter = Segmenter.word,
         length: int = 1,
         force: bool = None,
-    ) -> List[Dict]:
+    ) -> List[Dict[str, Union[float, str]]]:
+        """Get timestamped transcript segments for the video.
+
+        :param int start: Start time in seconds
+        :param int end: End time in seconds
+        :param Segmenter segmenter: Segmentation type (:class:`Segmenter.word`,
+            :class:`Segmenter.sentence`, :class:`Segmenter.time`)
+        :param int length: Length of segments when using time segmenter
+        :param bool force: Force fetch new transcript
+        :return: List of dicts with keys: start (float), end (float), text (str)
+        :rtype: List[Dict[str, Union[float, str]]]
+        """
         self._fetch_transcript(
             start=start, end=end, segmenter=segmenter, length=length, force=force
         )
@@ -179,6 +236,14 @@ def get_transcript_text(
         length: int = 1,
         force: bool = None,
     ) -> str:
+        """Get plain text transcript for the video.
+
+        :param int start: Start time in seconds to get transcript from
+        :param int end: End time in seconds to get transcript until
+        :param bool force: Force fetch new transcript
+        :return: Full transcript text as string
+        :rtype: str
+        """
         self._fetch_transcript(
             start=start, end=end, segmenter=segmenter, length=length, force=force
         )
@@ -190,8 +255,11 @@ def index_spoken_words(
         force: bool = False,
         callback_url: str = None,
     ) -> None:
-        """Semantic indexing of spoken words in the video
+        """Semantic indexing of spoken words in the video.
 
+        :param str language_code: (optional) Language code of the video
+        :param bool force: (optional) Force to index the video
+        :param str callback_url: (optional) URL to receive the callback
         :raises InvalidRequestError: If the video is already indexed
         :return: None if the indexing is successful
         :rtype: None
@@ -208,6 +276,15 @@ def index_spoken_words(
         )
 
     def get_scenes(self) -> Union[list, None]:
+        """
+        .. deprecated:: 0.2.0
+        Use :func:`list_scene_index` and :func:`get_scene_index` instead.
+
+        Get the scenes of the video.
+
+        :return: The scenes of the video
+        :rtype: list
+        """
         if self.scenes:
             return self.scenes
         scene_data = self._connection.get(
@@ -261,6 +338,31 @@ def extract_scenes(
         force: bool = False,
         callback_url: str = None,
     ) -> Optional[SceneCollection]:
+        """Extract the scenes of the video.
+
+        :param SceneExtractionType extraction_type: (optional) The type of extraction, :class:`SceneExtractionType <SceneExtractionType>` object
+        :param dict extraction_config: (optional) Dictionary of configuration parameters to control how scenes are extracted.
+            For time-based extraction (extraction_type=time_based):\n
+                - "time" (int, optional): Interval in seconds at which scenes are
+                  segmented. Default is 10 (i.e., every 10 seconds forms a new scene).
+                - "frame_count" (int, optional): Number of frames to extract per
+                  scene. Default is 1.
+                - "select_frames" (List[str], optional): Which frames to select from
+                  each segment. Possible values include "first", "middle", and "last".
+                  Default is ["first"].
+
+            For shot-based extraction (extraction_type=shot_based):\n
+                - "threshold" (int, optional): Sensitivity for detecting scene changes
+                  (camera shots). The higher the threshold, the fewer scene splits.
+                  Default is 20.
+                - "frame_count" (int, optional): Number of frames to extract from
+                  each detected shot. Default is 1.
+        :param bool force: (optional) Force to extract the scenes
+        :param str callback_url: (optional) URL to receive the callback
+        :raises InvalidRequestError: If the extraction fails
+        :return: The scene collection, :class:`SceneCollection <SceneCollection>` object
+        :rtype: :class:`videodb.scene.SceneCollection`
+        """
         scenes_data = self._connection.post(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.scenes}",
             data={
@@ -275,6 +377,12 @@ def extract_scenes(
         return self._format_scene_collection(scenes_data.get("scene_collection"))
 
     def get_scene_collection(self, collection_id: str) -> Optional[SceneCollection]:
+        """Get the scene collection.
+
+        :param str collection_id: The id of the scene collection
+        :return: The scene collection
+        :rtype: :class:`videodb.scene.SceneCollection`
+        """
         if not collection_id:
             raise ValueError("collection_id is required")
         scenes_data = self._connection.get(
@@ -286,6 +394,11 @@ def get_scene_collection(self, collection_id: str) -> Optional[SceneCollection]:
         return self._format_scene_collection(scenes_data.get("scene_collection"))
 
     def list_scene_collection(self):
+        """List all the scene collections.
+
+        :return: The scene collections
+        :rtype: list
+        """
         scene_collections_data = self._connection.get(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.scenes}",
             params={"collection_id": self.collection_id},
@@ -293,6 +406,13 @@ def list_scene_collection(self):
         return scene_collections_data.get("scene_collections", [])
 
     def delete_scene_collection(self, collection_id: str) -> None:
+        """Delete the scene collection.
+
+        :param str collection_id: The id of the scene collection to be deleted
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         if not collection_id:
             raise ValueError("collection_id is required")
         self._connection.delete(
@@ -311,6 +431,35 @@ def index_scenes(
         scenes: Optional[List[Scene]] = None,
         callback_url: Optional[str] = None,
     ) -> Optional[str]:
+        """Index the scenes of the video.
+
+        :param SceneExtractionType extraction_type: (optional) The type of extraction, :class:`SceneExtractionType <SceneExtractionType>` object
+        :param dict extraction_config: (optional) Dictionary of configuration parameters to control how scenes are extracted.
+            For time-based extraction (extraction_type=time_based):\n
+                - "time" (int, optional): Interval in seconds at which scenes are
+                  segmented. Default is 10 (i.e., every 10 seconds forms a new scene).
+                - "frame_count" (int, optional): Number of frames to extract per
+                  scene. Default is 1.
+                - "select_frames" (List[str], optional): Which frames to select from
+                  each segment. Possible values include "first", "middle", and "last".
+                  Default is ["first"].
+
+            For shot-based extraction (extraction_type=shot_based):\n
+                - "threshold" (int, optional): Sensitivity for detecting scene changes
+                  (camera shots). The higher the threshold, the fewer scene splits.
+                  Default is 20.
+                - "frame_count" (int, optional): Number of frames to extract from
+                  each detected shot. Default is 1.
+        :param str prompt: (optional) The prompt for the extraction
+        :param str model_name: (optional) The model name for the extraction
+        :param dict model_config: (optional) The model configuration for the extraction
+        :param str name: (optional) The name of the scene index
+        :param list[Scene] scenes: (optional) The scenes to be indexed, List of :class:`Scene <Scene>` objects
+        :param str callback_url: (optional) The callback url
+        :raises InvalidRequestError: If the index fails or index already exists
+        :return: The scene index id
+        :rtype: str
+        """
         scenes_data = self._connection.post(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.index}/{ApiPath.scene}",
             data={
@@ -330,6 +479,11 @@ def index_scenes(
         return scenes_data.get("scene_index_id")
 
     def list_scene_index(self) -> List:
+        """List all the scene indexes.
+
+        :return: The scene indexes
+        :rtype: list
+        """
         index_data = self._connection.get(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.index}/{ApiPath.scene}",
             params={"collection_id": self.collection_id},
@@ -337,6 +491,12 @@ def list_scene_index(self) -> List:
         return index_data.get("scene_indexes", [])
 
     def get_scene_index(self, scene_index_id: str) -> Optional[List]:
+        """Get the scene index.
+
+        :param str scene_index_id: The id of the scene index
+        :return: The scene index records
+        :rtype: list
+        """
         index_data = self._connection.get(
             path=f"{ApiPath.video}/{self.id}/{ApiPath.index}/{ApiPath.scene}/{scene_index_id}",
             params={"collection_id": self.collection_id},
@@ -346,6 +506,13 @@ def get_scene_index(self, scene_index_id: str) -> Optional[List]:
         return index_data.get("scene_index_records", [])
 
     def delete_scene_index(self, scene_index_id: str) -> None:
+        """Delete the scene index.
+
+        :param str scene_index_id: The id of the scene index to be deleted
+        :raises InvalidRequestError: If the delete fails
+        :return: None if the delete is successful
+        :rtype: None
+        """
         if not scene_index_id:
             raise ValueError("scene_index_id is required")
         self._connection.delete(
@@ -353,6 +520,12 @@ def delete_scene_index(self, scene_index_id: str) -> None:
         )
 
     def add_subtitle(self, style: SubtitleStyle = SubtitleStyle()) -> str:
+        """Add subtitles to the video.
+
+        :param SubtitleStyle style: (optional) The style of the subtitles, :class:`SubtitleStyle <SubtitleStyle>` object
+        :return: The stream url of the video with subtitles
+        :rtype: str
+        """
         if not isinstance(style, SubtitleStyle):
             raise ValueError("style must be of type SubtitleStyle")
         subtitle_data = self._connection.post(
@@ -404,9 +577,9 @@ def insert_video(self, video, timestamp: float) -> str:
         return compile_data.get("stream_url", None)
 
     def play(self) -> str:
-        """Open the player url in the browser/iframe and return the stream url
+        """Open the player url in the browser/iframe and return the stream url.
 
-        :return: The stream url
+        :return: The player url
         :rtype: str
         """
         return play_stream(self.stream_url)