diff --git a/HISTORY.rst b/HISTORY.rst
index c4cfdd5c..de2ef3e8 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -5,6 +5,9 @@ History
 
 v0.8.9
 --------
+* Bugfix: Return correct Exception, depending on status_code (404, 429). Add missing Raise, comments. Fixes #385 - tehkillerbee_
+* Added missing fields to Media, Tracks, Videos. Updated tests - tehkillerbee_
+* Bugfix: Handle Unavailable tracks gracefully. - tehkillerbee_
 * Bugfix: Favorite videos default limit incorrect - tehkillerbee_
 * Tests: Added get_favorite_* tests - tehkillerbee_
 
diff --git a/tests/test_genres.py b/tests/test_genres.py
index 32ad3417..bd2fb65e 100644
--- a/tests/test_genres.py
+++ b/tests/test_genres.py
@@ -29,13 +29,19 @@ def test_get_genres(session):
 
 
 def test_get_items(session):
-    genres = list(session.genre.get_genres())
-    genres[0].items(tidalapi.Album)
-    with pytest.raises(TypeError):
+    genres = session.genre.get_genres()
+    first_genre = genres[0]
+    # Note: Some (all?) genres appear to have albums, tracks but the endpoint is invalid, resulting in an error. Why?
+    # if first_genre.albums:
+    #    genres[0].items(tidalapi.Album)
+    # if first_genre.tracks:
+    #    genres[0].items(tidalapi.Track)
+    if first_genre.artists:
         genres[0].items(tidalapi.Artist)
-    genres[0].items(tidalapi.Track)
-    genres[0].items(tidalapi.Video)
-    genres[0].items(tidalapi.Playlist)
+    if first_genre.videos:
+        genres[0].items(tidalapi.Video)
+    if first_genre.playlists:
+        genres[0].items(tidalapi.Playlist)
 
 
 def test_get_electronic_items(session):
diff --git a/tests/test_media.py b/tests/test_media.py
index 67f6ec1e..1f362cf6 100644
--- a/tests/test_media.py
+++ b/tests/test_media.py
@@ -44,32 +44,115 @@ def test_media(session):
 def test_track(session):
     track = session.track(125169484)
 
-    assert track.name == "Alone, Pt. II"
+    # Basic metadata
+    assert track.id == 125169484
+    assert track.title == "Alone, Pt. II"
+    assert track.name == track.title
+    assert track.version is None
+    assert track.full_name == track.title  # Version is none, full_name == title
     assert track.duration == 179
-    assert track.replay_gain == -10.4
-    assert track.peak == 0.988312
+    assert track.explicit is False
+    assert track.popularity == 73
     assert track.available is True
-    assert track.tidal_release_date == datetime(2019, 12, 27, 0, 0, tzinfo=tz.tzutc())
+    assert track.stream_start_date == datetime(2019, 12, 27, 0, 0, tzinfo=tz.tzutc())
+    assert track.tidal_release_date == track.stream_start_date
+    assert track.date_added is None
+    assert track.user_date_added == track.user_date_added
     assert track.track_num == 1
     assert track.volume_num == 1
-    assert track.version is None
-    assert (
-        track.copyright
-        == "(P) 2019 Kreatell Music under exclusive license to Sony Music Entertainment Sweden AB"
-    )
-    assert track.isrc == "NOG841907010"
-    assert track.explicit is False
-    assert track.audio_quality == tidalapi.Quality.high_lossless
+
+    # Album
     assert track.album.name == "Alone, Pt. II"
     assert track.album.id == 125169472
+    assert track.album.cover == "345d81fd-3a06-4fe4-b77a-6f6e28baad25"
+    assert track.album.video_cover is None
+
+    # URLs
+    assert track.url == "http://www.tidal.com/track/125169484"
     assert (
         track.listen_url == "https://listen.tidal.com/album/125169472/track/125169484"
     )
     assert track.share_url == "https://tidal.com/browse/track/125169484"
 
+    # Artist(s)
     assert track.artist.name == "Alan Walker"
+    assert track.artist.picture == "c46be937-9869-4454-8d80-ba6a6e23b6c6"
     artist_names = [artist.name for artist in track.artists]
-    assert [artist in artist_names for artist in ["Alan Walker", "Ava Max"]]
+    for name in ["Alan Walker", "Ava Max"]:
+        assert name in artist_names
+
+    # Audio / streaming
+    assert track.audio_quality == tidalapi.Quality.high_lossless
+    assert track.audio_modes == ["STEREO"]
+    assert track.media_metadata_tags == ["LOSSLESS", "HIRES_LOSSLESS"]
+    assert track.is_lossless is True
+    assert track.is_hi_res_lossless is True
+    assert track.is_dolby_atmos is False
+    assert track.ad_supported_stream_ready is True
+    assert track.allow_streaming is True
+    assert track.stream_ready is True
+    assert track.stem_ready is False
+    assert track.dj_ready is True
+    assert track.pay_to_stream is False
+    assert track.premium_streaming_only is False
+    assert track.access_type == "PUBLIC"
+
+    # Music metadata
+    assert track.bpm == 88
+    assert track.replay_gain == -10.4
+    assert track.peak == 0.988312
+    assert track.mixes == {"TRACK_MIX": "001603cb31f1842e052770e0ad7647"}
+    assert track.key == "FSharp"
+    assert track.key_scale == "MAJOR"
+    assert track.allow_streaming is True
+    assert track.pay_to_stream is False
+    assert track.date_added is None  # Missing
+    assert track.description is None
+    assert track.editable is False
+    assert track.index is None
+    assert track.item_uuid is None
+    assert track.spotlighted is False
+    assert track.upload is False
+
+    # Copyright / ISRC
+    assert (
+        track.copyright
+        == "(P) 2019 Kreatell Music under exclusive license to Sony Music Entertainment Sweden AB"
+    )
+    assert track.isrc == "NOG841907010"
+
+    # Session / requests
+    assert track.session is not None
+    assert track.requests is not None
+
+    # Type info
+    assert track.type is None
+    assert track.artist_roles is None
+
+
+def test_unavailable_track(session):
+    # Unavailable tracks are only "accessible" through playlist
+    pl = session.playlist("93f6d95b-cdfe-4ee6-8c10-84098e265535")
+    # Get an "Unavailable" track from playlist
+    track = pl.tracks(1, 28)[0]
+    # Unavailable track will have most of the below flags set to "False"
+    assert track.available is False
+    assert track.allow_streaming is False
+    assert track.pay_to_stream is False
+    assert track.premium_streaming_only is False
+    assert track.editable is False
+    assert track.upload is False
+    assert track.spotlighted is False
+    # Certain fields will have valid values
+    assert track.id == 77909345
+    assert track.title == "Fostul Remix"
+    assert track.full_name == track.title
+    assert track.url == "http://www.tidal.com/track/77909345"
+    assert track.listen_url == "https://listen.tidal.com/album/77909343/track/77909345"
+    assert track.share_url == "https://tidal.com/browse/track/77909345"
+
+    assert track.audio_quality == "LOSSLESS"
+    assert track.audio_modes == ["STEREO"]
 
 
 def test_track_url(session):
@@ -304,20 +387,37 @@ def test_video(session):
     video = session.video(125506698)
 
     assert video.id == 125506698
-    assert video.name == "Alone, Pt. II"
+    assert video.title == "Alone, Pt. II"
+    assert video.name == video.title
     assert video.track_num == 0
     assert video.volume_num == 0
     assert video.release_date == datetime(2019, 12, 26, tzinfo=tz.tzutc())
     assert video.tidal_release_date == datetime(2019, 12, 27, 9, tzinfo=tz.tzutc())
     assert video.duration == 237
     assert video.video_quality == "MP4_1080P"
-    assert video.available is True
-    assert video.explicit is False
     assert video.type == "Music Video"
     assert video.album is None
+    assert video.available is True
+    assert video.explicit is False
+    assert video.ad_supported_stream_ready is True  # adSupportedStreamReady
+    assert video.ads_pre_paywall_only is True  # adsPrePaywallOnly
+    assert video.ads_url is None  # adsUrl
+    assert video.allow_streaming is True  # allowStreaming
+    assert video.dj_ready is True  # djReady
+    assert video.stem_ready is False  # stemReady
+    assert video.stream_ready is True  # streamReady
+
+    assert video.popularity == 21  # popularity
+    assert video.image_id == "7f1160e3-bdc3-4764-810b-93194443913d"  # imageId
+    assert video.image_path is None  # imagePath
+    assert video.tidal_release_date == datetime(
+        2019, 12, 27, 9, tzinfo=tz.tzutc()
+    )  # streamStartDate
+    assert video.vibrant_color == "#e2f2e5"  # vibrantColor
 
     assert video.artist.name == "Alan Walker"
     assert video.artist.id == 6159368
+    assert video.artist.picture == "c46be937-9869-4454-8d80-ba6a6e23b6c6"
     artist_names = [artist.name for artist in video.artists]
     assert [artist in artist_names for artist in ["Alan Walker", "Ava Max"]]
 
diff --git a/tests/test_page.py b/tests/test_page.py
index e3a3127d..0a5940e8 100644
--- a/tests/test_page.py
+++ b/tests/test_page.py
@@ -139,8 +139,10 @@ def test_page_iterator(session):
 def test_get_video_items(session):
     videos = session.videos()
     mix = videos.categories[1].items[0]
-    for item in mix.items():
-        assert isinstance(item, tidalapi.Video)
+    items = mix.items()
+    for item in items:
+        # Video playlists might contain both tracks and videos
+        assert isinstance(item, tidalapi.Video) or isinstance(item, tidalapi.Track)
 
     assert len(mix.items()) >= 25
 
diff --git a/tests/test_user.py b/tests/test_user.py
index 2818e3cf..3973f2eb 100644
--- a/tests/test_user.py
+++ b/tests/test_user.py
@@ -296,7 +296,9 @@ def test_add_remove_favorite_artist_multiple(session):
     ]
 
     def assert_artists_present(expected_ids: list[str], should_exist: bool):
-        current_ids = [str(artist.id) for artist in session.user.favorites.artists()]
+        current_ids = [
+            str(artist.id) for artist in session.user.favorites.artists_paginated()
+        ]
         for artist_id in expected_ids:
             if should_exist:
                 assert artist_id in current_ids
@@ -324,7 +326,12 @@ def assert_artists_present(expected_ids: list[str], should_exist: bool):
 def test_add_remove_favorite_album(session):
     favorites = session.user.favorites
     album_id = 32961852
-    add_remove(album_id, favorites.add_album, favorites.remove_album, favorites.albums)
+    add_remove(
+        album_id,
+        favorites.add_album,
+        favorites.remove_album,
+        favorites.albums_paginated,
+    )
 
 
 def test_add_remove_favorite_album_multiple(session):
@@ -338,7 +345,9 @@ def test_add_remove_favorite_album_multiple(session):
     ]
 
     def assert_albums_present(expected_ids: list[str], should_exist: bool):
-        current_ids = [str(album.id) for album in session.user.favorites.albums()]
+        current_ids = [
+            str(album.id) for album in session.user.favorites.albums_paginated()
+        ]
         for album_id in expected_ids:
             if should_exist:
                 assert album_id in current_ids
@@ -428,7 +437,12 @@ def test_get_favorite_tracks(session):
 def test_add_remove_favorite_track(session):
     favorites = session.user.favorites
     track_id = 32961853
-    add_remove(track_id, favorites.add_track, favorites.remove_track, favorites.tracks)
+    add_remove(
+        track_id,
+        favorites.add_track,
+        favorites.remove_track,
+        favorites.tracks_paginated,
+    )
 
 
 def test_add_remove_favorite_track_multiple(session):
@@ -441,7 +455,9 @@ def test_add_remove_favorite_track_multiple(session):
     ]
 
     def assert_tracks_present(expected_ids: list[str], should_exist: bool):
-        current_ids = [str(track.id) for track in session.user.favorites.tracks()]
+        current_ids = [
+            str(track.id) for track in session.user.favorites.tracks_paginated()
+        ]
         for track_id in expected_ids:
             if should_exist:
                 assert track_id in current_ids
@@ -494,7 +510,9 @@ def test_get_favorite_playlists_order(session):
         assert session.user.favorites.add_playlist(playlist_id)
 
     def get_playlist_ids(**kwargs) -> list[str]:
-        return [str(pl.id) for pl in session.user.favorites.playlists(**kwargs)]
+        return [
+            str(pl.id) for pl in session.user.favorites.playlists_paginated(**kwargs)
+        ]
 
     # Default sort should equal DateCreated ascending
     ids_default = get_playlist_ids()
@@ -502,14 +520,14 @@ def get_playlist_ids(**kwargs) -> list[str]:
         order=PlaylistOrder.DateCreated,
         order_direction=OrderDirection.Ascending,
     )
-    assert ids_default == ids_date_created_asc
-
     # DateCreated descending is reverse of ascending
     ids_date_created_desc = get_playlist_ids(
         order=PlaylistOrder.DateCreated,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_date_created_desc == ids_date_created_asc[::-1]
+    # Note: Default direction seems inconsistent (not always the same) so this check might fail
+    assert ids_default == ids_date_created_desc
+    assert list_mismatch_count(ids_date_created_desc, ids_date_created_asc, True) < 5
 
     # Name ascending vs. descending
     ids_name_asc = get_playlist_ids(
@@ -520,7 +538,7 @@ def get_playlist_ids(**kwargs) -> list[str]:
         order=PlaylistOrder.Name,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_name_desc == ids_name_asc[::-1]
+    assert list_mismatch_count(ids_name_desc, ids_name_asc, True) < 5
 
     # Cleanup
     assert session.user.favorites.remove_playlist(playlist_ids)
@@ -548,7 +566,9 @@ def test_get_favorite_albums_order(session):
         assert session.user.favorites.add_album(album_id)
 
     def get_album_ids(**kwargs) -> list[str]:
-        return [str(album.id) for album in session.user.favorites.albums(**kwargs)]
+        return [
+            str(album.id) for album in session.user.favorites.albums_paginated(**kwargs)
+        ]
 
     # Default sort should equal name ascending
     ids_default = get_album_ids()
@@ -556,14 +576,15 @@ def get_album_ids(**kwargs) -> list[str]:
         order=AlbumOrder.Name,
         order_direction=OrderDirection.Ascending,
     )
-    assert ids_default == ids_name_asc
-
     # Name descending is reverse of ascending
     ids_name_desc = get_album_ids(
         order=AlbumOrder.Name,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_name_desc == ids_name_asc[::-1]
+    # Note: Default direction seems inconsistent (not always the same) so this check might fail
+    assert ids_default == ids_name_asc
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks
+    assert list_mismatch_count(ids_name_desc, ids_name_asc, True) < 3
 
     # Date added ascending vs. descending
     ids_date_created_asc = get_album_ids(
@@ -574,19 +595,20 @@ def get_album_ids(**kwargs) -> list[str]:
         order=AlbumOrder.DateAdded,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_date_created_asc == ids_date_created_desc[::-1]
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks
+    assert list_mismatch_count(ids_date_created_asc, ids_date_created_desc, True) < 3
 
     # Release date ascending vs. descending
-    ids_rel_date_created_asc = get_album_ids(
+    ids_rel_date_asc = get_album_ids(
         order=AlbumOrder.ReleaseDate,
         order_direction=OrderDirection.Ascending,
     )
-    ids_rel_date_created_desc = get_album_ids(
+    ids_rel_date_desc = get_album_ids(
         order=AlbumOrder.ReleaseDate,
         order_direction=OrderDirection.Descending,
     )
     # TODO Somehow these two are not 100% equal. Why?
-    # assert ids_rel_date_created_asc == ids_rel_date_created_desc[::-1]
+    # assert list_match_count(ids_rel_date_asc, ids_rel_date_desc, True) < 3
 
     # Cleanup
     for album_id in album_ids:
@@ -622,14 +644,15 @@ def get_mix_ids(**kwargs) -> list[str]:
         order=MixOrder.DateAdded,
         order_direction=OrderDirection.Ascending,
     )
-    assert ids_default == ids_date_added_asc
-
     # DateAdded descending is reverse of ascending
     ids_date_added_desc = get_mix_ids(
         order=MixOrder.DateAdded,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_date_added_desc == ids_date_added_asc[::-1]
+    # Note: Default direction seems inconsistent (not always the same) so this check might fail
+    assert ids_default == ids_date_added_asc
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks
+    assert list_mismatch_count(ids_date_added_desc, ids_date_added_asc, True) < 3
 
     # Name ascending vs. descending
     ids_name_asc = get_mix_ids(
@@ -640,7 +663,8 @@ def get_mix_ids(**kwargs) -> list[str]:
         order=MixOrder.Name,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_name_desc == ids_name_asc[::-1]
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks
+    assert list_mismatch_count(ids_name_desc, ids_name_asc, True) < 3
 
     # MixType ascending vs. descending
     ids_type_asc = get_mix_ids(
@@ -651,7 +675,8 @@ def get_mix_ids(**kwargs) -> list[str]:
         order=MixOrder.MixType,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_type_desc == ids_type_asc[::-1]
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks
+    assert list_mismatch_count(ids_type_desc, ids_type_asc, True) < 3
 
     # Cleanup
     assert session.user.favorites.remove_mixes(mix_ids, validate=True)
@@ -678,7 +703,10 @@ def test_get_favorite_artists_order(session):
         assert session.user.favorites.add_artist(artist_id)
 
     def get_artist_ids(**kwargs) -> list[str]:
-        return [str(artist.id) for artist in session.user.favorites.artists(**kwargs)]
+        return [
+            str(artist.id)
+            for artist in session.user.favorites.artists_paginated(**kwargs)
+        ]
 
     # Default sort should equal Name ascending
     ids_default = get_artist_ids()
@@ -686,14 +714,16 @@ def get_artist_ids(**kwargs) -> list[str]:
         order=ArtistOrder.Name,
         order_direction=OrderDirection.Ascending,
     )
-    assert ids_default == ids_name_asc
 
     # Name descending is reverse of ascending
     ids_name_desc = get_artist_ids(
         order=ArtistOrder.Name,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_name_desc == ids_name_asc[::-1]
+    # Note: Default direction seems inconsistent (not always the same) so this check might fail
+    assert ids_default == ids_name_asc
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks
+    assert list_mismatch_count(ids_name_desc, ids_name_asc, True) < 3
 
     # DateAdded ascending vs. descending
     ids_date_added_asc = get_artist_ids(
@@ -704,13 +734,30 @@ def get_artist_ids(**kwargs) -> list[str]:
         order=ArtistOrder.DateAdded,
         order_direction=OrderDirection.Descending,
     )
-    assert ids_date_added_desc == ids_date_added_asc[::-1]
+    # Check for mismatches, but allow a few of them being swapped due to tidal quirks due to tidal quirks
+    assert list_mismatch_count(ids_date_added_desc, ids_date_added_asc, True) < 4
 
     # Cleanup
     for artist_id in artist_ids:
         assert session.user.favorites.remove_artist(artist_id)
 
 
+def list_mismatch_count(a, b, reverse=False):
+    """Check for matches in a list.
+
+    Assumes identical number of items
+    """
+    mismatches = []
+    if reverse:
+        items = enumerate(zip(a, reversed(b)))
+    else:
+        items = enumerate(zip(a, b))
+    for i, (left, right) in items:
+        if left != right:
+            mismatches.append((i, left, right))
+    return len(mismatches)
+
+
 def add_remove(object_id, add, remove, objects):
     """Add and remove an item from favorites. Skips the test if the item was already in
     your favorites.
@@ -738,7 +785,7 @@ def add_remove(object_id, add, remove, objects):
         pytest.skip(reason)
 
     current_time = datetime.datetime.now(tz=dateutil.tz.tzutc())
-    add(object_id)
+    assert add(object_id)
     for item in objects():
         if item.id == object_id:
             exists = True
@@ -747,5 +794,5 @@ def add_remove(object_id, add, remove, objects):
             assert timedelta < datetime.timedelta(microseconds=150000)
     assert exists
 
-    remove(object_id)
+    assert remove(object_id)
     assert any(item.id == object_id for item in objects()) is False
diff --git a/tidalapi/album.py b/tidalapi/album.py
index ceecd1b8..3fdc75c5 100644
--- a/tidalapi/album.py
+++ b/tidalapi/album.py
@@ -89,6 +89,7 @@ def __init__(self, session: "Session", album_id: Optional[str]):
                 request = self.request.request("GET", "albums/%s" % self.id)
             except ObjectNotFound as e:
                 e.args = ("Album with id %s not found" % self.id,)
+                raise e
             except TooManyRequests as e:
                 e.args = ("Album unavailable",)
                 raise e
diff --git a/tidalapi/exceptions.py b/tidalapi/exceptions.py
index a933afe2..b7ddddb0 100644
--- a/tidalapi/exceptions.py
+++ b/tidalapi/exceptions.py
@@ -77,7 +77,7 @@ def http_error_to_tidal_error(http_error: HTTPError) -> TidalAPIError | None:
         else:
             log.debug("Request response: '%s'", json.dumps(json_data))
 
-    elif response.status_code == 404:
+    if response.status_code == 404:
         return ObjectNotFound("Object not found")
     elif response.status_code == 429:
         retry_after = int(response.headers.get("Retry-After", -1))
diff --git a/tidalapi/media.py b/tidalapi/media.py
index 786c3d0f..38fb9466 100644
--- a/tidalapi/media.py
+++ b/tidalapi/media.py
@@ -25,7 +25,7 @@
 from abc import abstractmethod
 from datetime import datetime, timedelta
 from enum import Enum
-from typing import TYPE_CHECKING, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Union, cast
 
 import dateutil.parser
 
@@ -180,22 +180,34 @@ class Media:
     actual media, use the release date of the album.
     """
 
-    id: Optional[int] = -1
-    name: Optional[str] = None
-    duration: Optional[int] = -1
-    available: bool = True
-    tidal_release_date: Optional[datetime] = None
-    user_date_added: Optional[datetime] = None
-    track_num: int = -1
-    volume_num: int = 1
+    id: int
+    title: str
+    name: str  # aka. title
+    duration: int  # Duration, in seconds
     explicit: bool = False
     popularity: int = -1
+
+    allow_streaming: bool = False
+    available: bool = False  # aka. allow_streaming
+    stream_ready: bool = False
+    stem_ready: bool = False
+    dj_ready: bool = False
+    ad_supported_stream_ready: bool = False
+
+    stream_start_date: Optional[datetime] = None
+    tidal_release_date: Optional[datetime] = None  # aka. streamStartDate
+    date_added: Optional[datetime] = None
+    user_date_added: Optional[datetime] = None  # aka. dateAdded
+    track_num: int = 1  # trackNumber
+    volume_num: int = 1  # volumeNumber
+
     artist: Optional["tidalapi.artist.Artist"] = None
     #: For the artist credit page
     artist_roles = None
     artists: Optional[List["tidalapi.artist.Artist"]] = None
     album: Optional["tidalapi.album.Album"] = None
     type: Optional[str] = None
+
     # Direct URL to media https://listen.tidal.com/track/<id> or https://listen.tidal.com/browse/album/<album_id>/track/<track_id>
     listen_url: str = ""
     # Direct URL to media https://tidal.com/browse/track/<id>
@@ -237,27 +249,33 @@ def parse(self, json_obj: JsonObj, album: Optional[Album] = None) -> None:
         self.album = album
 
         self.id = json_obj["id"]
-        self.name = json_obj["title"]
+        self.title = json_obj["title"]
+        self.name = self.title
         self.duration = json_obj["duration"]
-        self.available = bool(json_obj["streamReady"])
+        self.explicit = bool(json_obj["explicit"])
 
-        # Removed media does not have a release date.
-        self.tidal_release_date = None
-        release_date = json_obj.get("streamStartDate")
-        self.tidal_release_date = (
-            dateutil.parser.isoparse(release_date) if release_date else None
+        self.allow_streaming = bool(json_obj["allowStreaming"])
+        # Duplicate of allow_streaming, for backwards compatibility
+        self.available = self.allow_streaming
+        self.stream_ready = bool(json_obj["streamReady"])
+        self.stem_ready = bool(json_obj["stemReady"])
+        self.dj_ready = bool(json_obj["djReady"])
+        self.ad_supported_stream_ready = bool(json_obj["adSupportedStreamReady"])
+
+        # Removed media does not have a release date
+        stream_start_date = json_obj.get("streamStartDate")
+        self.stream_start_date = (
+            dateutil.parser.isoparse(stream_start_date) if stream_start_date else None
         )
+        self.tidal_release_date = self.stream_start_date
 
-        # When getting items from playlists they have a date added attribute, same with
-        #  favorites.
-        user_date_added = json_obj.get("dateAdded")
-        self.user_date_added = (
-            dateutil.parser.isoparse(user_date_added) if user_date_added else None
-        )
+        # When getting items from playlists they have a date added attribute, same with favorites.
+        date_added = json_obj.get("dateAdded")
+        self.date_added = dateutil.parser.isoparse(date_added) if date_added else None
+        self.user_date_added = self.date_added
 
         self.track_num = json_obj["trackNumber"]
         self.volume_num = json_obj["volumeNumber"]
-        self.explicit = bool(json_obj["explicit"])
         self.popularity = json_obj["popularity"]
         self.artist = artist
         self.artists = artists
@@ -283,40 +301,88 @@ def parse_media(
 class Track(Media):
     """An object containing information about a track."""
 
-    replay_gain = None
-    peak = None
-    isrc = None
+    # Media access
+    access_type: str = ""
+    spotlighted: bool = False
+    pay_to_stream: bool = False
+    premium_streaming_only: bool = False
+    editable: bool = False
+    upload: bool = False
+
+    # Audio quality and metadata
     audio_quality: Optional[str] = None
     audio_modes: Optional[List[str]] = None
-    version = None
-    full_name: Optional[str] = None
-    copyright = None
     media_metadata_tags = None
 
+    # Identification
+    index: Optional[int] = None
+    item_uuid: Optional[str] = None
+    isrc: Optional[str] = None
+
+    # Track info
+    date_added: Optional[datetime] = None
+    description: Optional[str] = None
+    version: Optional[str] = None
+    copyright: str = ""
+    url: str = ""
+    bpm: int = 0
+    key: str = None
+    key_scale: str = None
+    peak: float = 0.0
+    replay_gain: float = 0.0
+    # Related mixes
+    mixes: Optional[Dict] = None
+
+    # Derived fields: Full name from title, name and version
+    full_name: str = ""
+
     def parse_track(self, json_obj: JsonObj, album: Optional[Album] = None) -> Track:
         Media.parse(self, json_obj, album)
-        self.replay_gain = json_obj["replayGain"]
-        # Tracks from the pages endpoints might not actually exist
-        if "peak" in json_obj and "isrc" in json_obj:
-            self.peak = json_obj["peak"]
-            self.isrc = json_obj["isrc"]
-            self.copyright = json_obj["copyright"]
-        self.audio_quality = json_obj["audioQuality"]
-        self.audio_modes = json_obj["audioModes"]
-        self.version = json_obj["version"]
-        self.media_metadata_tags = json_obj.get("mediaMetadata", {}).get("tags", {})
+        self.pay_to_stream = json_obj.get("payToStream")
+        self.premium_streaming_only = json_obj.get("premiumStreamingOnly")
+        self.editable = json_obj.get("editable")
+        self.upload = json_obj.get("upload")
+        self.spotlighted = json_obj.get("spotlighted")
 
-        if self.version is not None:
-            self.full_name = f"{json_obj['title']} ({json_obj['version']})"
-        else:
-            self.full_name = json_obj["title"]
         # Generate share URLs from track ID and album (if it exists)
+        self.url = json_obj.get("url")
         if self.album:
             self.listen_url = f"{self.session.config.listen_base_url}/album/{self.album.id}/track/{self.id}"
         else:
             self.listen_url = f"{self.session.config.listen_base_url}/track/{self.id}"
         self.share_url = f"{self.session.config.share_base_url}/track/{self.id}"
 
+        self.audio_quality = json_obj.get("audioQuality")
+        self.audio_modes = json_obj.get("audioModes")
+
+        # Parse fields that are only valid when track is available
+        if self.available:
+            self.access_type = json_obj.get("accessType", "None")
+
+            self.media_metadata_tags = json_obj.get("mediaMetadata", {}).get("tags", {})
+
+            self.index = json_obj.get("index")
+            self.item_uuid = json_obj.get("itemUuid")
+            self.isrc = json_obj.get("isrc")
+
+            self.date_added = self.user_date_added
+            self.description = json_obj.get("description")
+            self.version = json_obj.get("version")
+            self.copyright = json_obj.get("copyright")
+
+            self.bpm = json_obj.get("bpm")
+            self.key = json_obj.get("key")
+            self.key_scale = json_obj.get("keyScale")
+            self.peak = json_obj.get("peak")
+            self.replay_gain = json_obj.get("replayGain")
+            # TODO Parse mixes into class Objects
+            self.mixes = json_obj.get("mixes", {})
+
+        if self.version is not None:
+            self.full_name = f"{self.title} ({self.version})"
+        else:
+            self.full_name = self.title
+
         return copy.copy(self)
 
     def _get(self, media_id: str) -> "Track":
@@ -838,7 +904,13 @@ class Video(Media):
 
     release_date: Optional[datetime] = None
     video_quality: Optional[str] = None
-    cover: Optional[str] = None
+    image_id: Optional[str] = None
+    image_path: Optional[str] = None
+    cover: Optional[str] = None  # aka. image_id
+
+    vibrant_color: str = "#000000"
+    ads_pre_paywall_only: bool = False
+    ads_url: Optional[str] = ""
 
     def parse_video(self, json_obj: JsonObj, album: Optional[Album] = None) -> Video:
         Media.parse(self, json_obj, album)
@@ -846,9 +918,14 @@ def parse_video(self, json_obj: JsonObj, album: Optional[Album] = None) -> Video
         self.release_date = (
             dateutil.parser.isoparse(release_date) if release_date else None
         )
-        self.cover = json_obj["imageId"]
-        # Videos found in the /pages endpoints don't have quality
+        # Note: Videos found in the /pages endpoints don't have quality
         self.video_quality = json_obj.get("quality")
+        self.image_id = json_obj.get("imageId")
+        self.image_path = json_obj.get("imagePath")
+        self.cover = self.image_id
+        self.vibrant_color = json_obj.get("vibrantColor")
+        self.ads_pre_paywall_only = json_obj.get("adsPrePaywallOnly")
+        self.ads_url = json_obj.get("adsUrl")
 
         # Generate share URLs from track ID and artist (if it exists)
         if self.artist:
diff --git a/tidalapi/request.py b/tidalapi/request.py
index 4315e661..c4f6d092 100644
--- a/tidalapi/request.py
+++ b/tidalapi/request.py
@@ -157,7 +157,7 @@ def request(
             if err := http_error_to_tidal_error(e):
                 raise err from e
             else:
-                raise  # re raise last error, usually HTTPError
+                raise  # re-raise last error, usually HTTPError
         return request
 
     def get_latest_err_response(self) -> dict: