429 Client Error: Too Many Requests for url: https://api.spotify.com/v1/me/

[mzilot]

[INFO 17:51:59] Starting Votify
Traceback (most recent call last):
File "/usr/local/lib/python3.10/site-packages/votify/utils.py", line 14, in check_response
response.raise_for_status()
File "/usr/local/lib/python3.10/site-packages/requests/models.py", line 1026, in raise_for_status
raise HTTPError(http_error_msg, response=self)
requests.exceptions.HTTPError: 429 Client Error: Too Many Requests for url: https://api.spotify.com/v1/me/

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File "/usr/local/bin/votify", line 8, in
sys.exit(main())
File "/usr/local/lib/python3.10/site-packages/click/core.py", line 1462, in call
return self.main(*args, **kwargs)
File "/usr/local/lib/python3.10/site-packages/click/core.py", line 1383, in main
rv = self.invoke(ctx)
File "/usr/local/lib/python3.10/site-packages/click/core.py", line 1246, in invoke
return ctx.invoke(self.callback, **ctx.params)
File "/usr/local/lib/python3.10/site-packages/click/core.py", line 814, in invoke
return callback(*args, **kwargs)
File "/usr/local/lib/python3.10/site-packages/votify/cli.py", line 429, in main
spotify_api = SpotifyApi.from_cookies_file(cookies_path)
File "/usr/local/lib/python3.10/site-packages/votify/spotify_api.py", line 76, in from_cookies_file
return cls(sp_dc=sp_dc)
File "/usr/local/lib/python3.10/site-packages/votify/spotify_api.py", line 56, in init
self._set_session()
File "/usr/local/lib/python3.10/site-packages/votify/spotify_api.py", line 83, in _set_session
self._setup_user_profile()
File "/usr/local/lib/python3.10/site-packages/votify/spotify_api.py", line 189, in _setup_user_profile
check_response(response)
File "/usr/local/lib/python3.10/site-packages/votify/utils.py", line 16, in check_response
_raise_response_exception(response)
File "/usr/local/lib/python3.10/site-packages/votify/utils.py", line 20, in _raise_response_exception
raise Exception(
Exception: Request failed with status code 429: {
"error": {
"status": 429,
"message": "API rate limit exceeded"
}
}

[vijaykrpp]

same here. tried tweaking headers, cookies, IP, etc but nothing worked.

[yashikada]

I think the issue is related to the Anna Archive leak, which took 300TB of data from Spotify.
My free account was canceled without warning.
I had downloaded 4 or 5 songs in 2 months with this account.

[vijaykrpp]

just got to know about Anna Archive leak. Could be the reason.

[neura-neura]

same issue here

[mzilot]

Is there any update regarding this issue?
@glomatico @deuslhepague @es3n1n @well0nez @grncd @KennethTrinh @blackicedbear

[yashikada]

I think this project is dead.
It's been 3 months since updates were released, and PRs that fix the issues are being ignored.
I'm evaluating zotify, user Googolplexed0's fork seems to be up to date.
They haven't fixed this issue yet, but at least they're working on it.

[GladistonXD]

Spotify replaces the 'https://api.spotify.com/v1/me/' with this request format:

    url = "https://api-partner.spotify.com/pathfinder/v2/query"
    track = '16xMPyMOeOR7WtJWVyb269'
    payload = {
        "variables": {
            "uri": f"spotify:track:{track}"
        },
        "operationName": "getTrack",
        "extensions": {
            "persistedQuery": {
                "version": 1,
                "sha256Hash": "612585ae06ba435ad26369870deaae23b5c8800a256cd8a57e08eddc25a37294"
            }
        }
    }

    response = session.post(
        url,
        json=payload,
    )

    print(response.json())

From there you can get all the information about the song, but you need to make some changes to the code.

[vijaykrpp]

Spotify replaces the 'https://api.spotify.com/v1/me/' with this request format:

url = "https://api-partner.spotify.com/pathfinder/v2/query"
track = '16xMPyMOeOR7WtJWVyb269'
payload = {
    "variables": {
        "uri": f"spotify:track:{track}"
    },
    "operationName": "getTrack",
    "extensions": {
        "persistedQuery": {
            "version": 1,
            "sha256Hash": "612585ae06ba435ad26369870deaae23b5c8800a256cd8a57e08eddc25a37294"
        }
    }
}

response = session.post(
    url,
    json=payload,
)

print(response.json())

From there you can get all the information about the song, but you need to make some changes to the code.

The url https://api.spotify.com/v1/me/ is used for profile setup. This is working in the API playground but stopped working in this project.

[GladistonXD]

The url https://api.spotify.com/v1/me/ is used for profile setup. This is working in the API playground but stopped working in this project.

The entire api has been replaced by https://api-partner.spotify.com/pathfinder/v2/query

what changes is the "operationName":
User:
"operationName": "accountAttributes"
Profile:
"operationName": "profileAttributes"
Song:
"operationName": "getTrack"
Album:
"operationName": "getAlbum"
Playlist:
"operationName": "fetchPlaylistContents"

Outputs:

profileAttributes
{
    "data": {
        "me": {
            "profile": {
                "avatar": null,
                "avatarBackgroundColor": 16085920,
                "name": "Spotify",
                "uri": "spotify:user:Unknow",
                "username": "Unknow"
            }
        }
    }
}

accountAttributes

{
    "data": {
        "me": {
            "account": {
                "attributes": {
                    "ads": true,
                    "ageAssuranceAccountWarningTimestamp": null,
                    "ageAssuranceEnabledAccountSettings": false,
                    "ageAssuranceState": "UNSET",
                    "catalogue": "free",
                    "dsaModeAvailable": false,
                    "dsaModeEnabled": false,
                    "estimatedAge": 20,
                    "filterExplicitContent": null,
                    "multiUserPlanCurrentSize": null,
                    "multiUserPlanMemberType": null,
                    "onDemand": false,
                    "optInTrialPremiumOnlyMarket": false,
                    "shouldAssureAgeContentPlayback": false,
                    "shouldAssureAgeSocial": false
                },
                "country": "EUA",
                "product": "FREE"
            }
        }
    }

[vijaykrpp]

The url https://api.spotify.com/v1/me/ is used for profile setup. This is working in the API playground but stopped working in this project.

The entire api has been replaced by https://api-partner.spotify.com/pathfinder/v2/query

what changes is the "operationName": User: "operationName": "accountAttributes" Profile: "operationName": "profileAttributes" Song: "operationName": "getTrack" Album: "operationName": "getAlbum" Playlist: "operationName": "fetchPlaylistContents"

Outputs:

profileAttributes
{
"data": {
"me": {
"profile": {
"avatar": null,
"avatarBackgroundColor": 16085920,
"name": "Spotify",
"uri": "spotify:user:Unknow",
"username": "Unknow"
}
}
}
}

accountAttributes

{
"data": {
"me": {
"account": {
"attributes": {
"ads": true,
"ageAssuranceAccountWarningTimestamp": null,
"ageAssuranceEnabledAccountSettings": false,
"ageAssuranceState": "UNSET",
"catalogue": "free",
"dsaModeAvailable": false,
"dsaModeEnabled": false,
"estimatedAge": 20,
"filterExplicitContent": null,
"multiUserPlanCurrentSize": null,
"multiUserPlanMemberType": null,
"onDemand": false,
"optInTrialPremiumOnlyMarket": false,
"shouldAssureAgeContentPlayback": false,
"shouldAssureAgeSocial": false
},
"country": "EUA",
"product": "FREE"
}
}
}

I tried and I got stucked at this level:

n download
    self._download(*args, **kwargs)
    ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^
  File "C:\Users\vijay\AppData\Local\Programs\Python\Python313\Lib\site-packages\votify\downloader_song.py", line 169, in _download
    stream_info = self.get_stream_info(gid_metadata, "track")
  File "C:\Users\vijay\AppData\Local\Programs\Python\Python313\Lib\site-packages\votify\downloader_audio.py", line 82, in get_stream_info
    audio_files = audio_files[0]["file"]
                  ~~~~~~~~~~~~~~^^^^^^^^
KeyError: 'file'
[INFO     10:15:11] Done (1 error(s))

[GladistonXD]

I tried and I got stucked at this level:

n download
    self._download(*args, **kwargs)
    ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^
  File "C:\Users\vijay\AppData\Local\Programs\Python\Python313\Lib\site-packages\votify\downloader_song.py", line 169, in _download
    stream_info = self.get_stream_info(gid_metadata, "track")
  File "C:\Users\vijay\AppData\Local\Programs\Python\Python313\Lib\site-packages\votify\downloader_audio.py", line 82, in get_stream_info
    audio_files = audio_files[0]["file"]
                  ~~~~~~~~~~~~~~^^^^^^^^
KeyError: 'file'
[INFO     10:15:11] Done (1 error(s))

I'll put together a simplified code for all the actions and send it here to use as a base, because my code was based on some things from the repository, but the way the actions are performed is quite different.

[GladistonXD]

You need to have a cookies.txt file in the same folder and a WVD key. My execution method is in binary form, but you can change the method, and also the files
mp4decrypt.exe and ffmpeg.exe.
I summarized as much as possible to be able to download a song; it can serve as a basis.

from pathlib import Path
from http.cookiejar import MozillaCookieJar
import requests
import time
import hmac
import hashlib
import math
from mutagen.mp4 import MP4, MP4Cover
from pywidevine import PSSH,Cdm,Device
import subprocess
import os
from yt_dlp import YoutubeDL
import shutil


class TOTP:
    def __init__(self) -> None:
        self.secret = b'376136387538459893883312310911992847112448894410210511297108'
        self.version = 61
        self.period = 30
        self.digits = 6

    def generate(self, timestamp: int) -> str:
        counter = math.floor(timestamp / 1000 / self.period)
        counter_bytes = counter.to_bytes(8, byteorder="big")

        h = hmac.new(self.secret, counter_bytes, hashlib.sha1)
        hmac_result = h.digest()

        offset = hmac_result[-1] & 0x0F
        binary = (
                (hmac_result[offset] & 0x7F) << 24
                | (hmac_result[offset + 1] & 0xFF) << 16
                | (hmac_result[offset + 2] & 0xFF) << 8
                | (hmac_result[offset + 3] & 0xFF)
        )

        return str(binary % (10 ** self.digits)).zfill(self.digits)

class SpotifyClient:
    def __init__(self):
        self.session = requests.Session()
        self.clienttoken = None
        self.get_session()


    def get_session(self):
        totp = TOTP()
        cookies_path = Path("./cookies.txt")

        if cookies_path.exists():
            cookies = MozillaCookieJar(str(cookies_path))
            cookies.load(ignore_discard=True, ignore_expires=True)
            self.session.cookies.update(cookies)

            for cookie in cookies:
                if cookie.name == "sp_t":
                    headerssp_t = {
                        "accept": "application/json",
                        "content-type": "application/json",
                        "origin": "https://open.spotify.com/",
                        "referer": "https://open.spotify.com/",
                        "user-agent": "Mozilla/5.0",
                        "spotify-app-version": "1.2.72.240.gf5884949",
                        "app-platform": "WebPlayer",
                        "cookie": f"sp_t={cookie.value};"
                    }

                    server_time = int(time.time() * 1000)
                    generated_totp = totp.generate(server_time)

                    session_info = requests.get(
                        "https://open.spotify.com/api/token",
                        params={
                            "reason": "init",
                            "productType": "web-player",
                            "totp": generated_totp,
                            "totpServer": generated_totp,
                            "totpVer": str(totp.version)
                        },
                        headers=headerssp_t
                    ).json()

                    response = requests.post(
                        "https://clienttoken.spotify.com/v1/clienttoken",
                        json={
                            "client_data": {
                                "client_version": "1.2.72.240.gf5884949",
                                "client_id": session_info["clientId"],
                                "js_sdk_data": {
                                    "device_id": cookie.value,
                                    "device_type": "computer"
                                }
                            }
                        },
                        headers=headerssp_t
                    )

                    self.clienttoken = response.json()["granted_token"]["token"]

        self.session.headers.update({
            "accept": "application/json",
            "content-type": "application/json",
            "origin": "https://open.spotify.com/",
            "referer": "https://open.spotify.com/",
            "user-agent": "Mozilla/5.0",
            "spotify-app-version": "1.2.72.240.gf5884949",
            "app-platform": "WebPlayer",
        })

        server_time = int(time.time() * 1000)
        generated_totp = totp.generate(server_time)

        session_info = self.session.get(
            "https://open.spotify.com/api/token",
            params={
                "reason": "init",
                "productType": "web-player",
                "totp": generated_totp,
                "totpServer": generated_totp,
                "totpVer": str(totp.version)
            }
        ).json()
        self.session.headers.update({
            "authorization": f"Bearer {session_info['accessToken']}",
            "client-token": self.clienttoken
        })

    def get_track(self, track_id: str) -> dict:
        url = "https://api-partner.spotify.com/pathfinder/v2/query"

        payload = {
            "variables": {
                "uri": f"spotify:track:{track_id}"
            },
            "operationName": "getTrack",
            "extensions": {
                "persistedQuery": {
                    "version": 1,
                    "sha256Hash": "612585ae06ba435ad26369870deaae23b5c8800a256cd8a57e08eddc25a37294"
                }
            }
        }

        response = self.session.post(
            url,
            json=payload,
        )
        response = response.json()
        return response

    def get_tags(self, track):
        album = self.get_track(track)
        track = album['data']['trackUnion']
        album_data = track['albumOfTrack']
        try:
            copyright = next(
                i['text']
                for i in album_data['copyright']['items']
                if i['type'] in ('P', 'C')
            )
        except StopIteration:
            copyright = ''

        date_info = album_data['date']
        if date_info['precision'] == 'YEAR':
            release_date = f"{date_info['year']}-01-01"
        else:
            release_date = date_info['isoString'][:10]

        total_tracks = album_data['tracks']['totalCount']
        total_discs = 1

        artist_name = album['data']['trackUnion']['firstArtist']['items'][0]['profile']['name']

        cover_url = max(
            album_data['coverArt']['sources'],
            key=lambda x: x['width']
        )['url']

        tags = {
            '\xa9nam': [track['name']],
            '\xa9ART': [artist_name],
            'aART': [artist_name],
            '\xa9alb': [album_data['name']],
            'trkn': [(track.get('trackNumber', 1), total_tracks)],
            'disk': [(1, total_discs)],
            '\xa9day': [f'{release_date}T00:00:00Z'],
            'covr': [
                MP4Cover(
                    requests.get(cover_url).content,
                    imageformat=MP4Cover.FORMAT_JPEG
                )
            ],
            '\xa9cmt': [
                f"https://open.spotify.com/track/{track['uri'].split(':')[-1]}"
            ],
            'cprt': [copyright],
            'rtng': [0],
        }
        return tags

    def audio_extracted(self, track, audio_quality):
        metamp4 = self.session.get(f'https://gue1-spclient.spotify.com/track-playback/v1/media/spotify:track:{track}?manifestFileFormat=file_ids_mp4').json()
        audio = next(
            f["file_id"]
            for track in metamp4["media"].values()
            for files in track["item"]["manifest"].values()
            if isinstance(files, list)
            for f in files
            if isinstance(f, dict) and f.get("bitrate") == int(audio_quality)
        )
        return audio

    def get_sanizated_string(self, dirty_string, is_folder):
        for character in ['\\', '/', ':', '*', '?', '"', '<', '>', '|', ';']:
            dirty_string = dirty_string.replace(character, '_')
        if is_folder:
            dirty_string = dirty_string[:40]
            if dirty_string[-1:] == '.':
                dirty_string = dirty_string[:-1] + '_'
        else:
            dirty_string = dirty_string[:80]
        return dirty_string.strip()

    def get_final_location(self, tags):
        if tags['disk'][0][1] > 1:
            file_name = self.get_sanizated_string(f'{tags["disk"][0][0]} {tags["©nam"][0]}', False) +'.m4a'
        else:
            file_name = self.get_sanizated_string(f'{tags["©nam"][0]}', False) +'.m4a'
        final = './Downloads' + '/' + self.get_sanizated_string(f"{tags['trkn'][0][0]:02d} {tags['aART'][0]}",True) + ' - ' + file_name
        return final

    def get_pssh(self, file_id):
        return self.session.get(f'https://seektables.scdn.co/seektable/{file_id}.json').json()['pssh']

    def accountAttributes(self):
        url = "https://api-partner.spotify.com/pathfinder/v2/query"
        payload = {
            "variables": {},
            "operationName": "accountAttributes",
            "extensions": {
                "persistedQuery": {
                    "version": 1,
                    "sha256Hash": "24aaa3057b69fa91492de26841ad199bd0b330ca95817b7a4d6715150de01827"
                }
            }
        }

        response = self.session.post(
            url,
            json=payload,
        )
        account = response.json()['data']['me']['account']['product']
        country = response.json()['data']['me']['account']['country']

        url = "https://api-partner.spotify.com/pathfinder/v2/query"
        payload = {
            "variables": {},
            "operationName": "profileAttributes",
            "extensions": {
                "persistedQuery": {
                    "version": 1,
                    "sha256Hash": "53bcb064f6cd18c23f752bc324a791194d20df612d8e1239c735144ab0399ced"
                }
            }
        }

        response = self.session.post(
            url,
            json=payload,
        )
        UserName = response.json()['data']['me']['profile']['username']

        mode = 'Country: ' + country + '\n' + 'Account: ' + account + '\n' + 'UserName: ' + UserName+ '\n'
        return mode

    def get_decryption_keys(self, pssh, wvd):
        cdm = Cdm.from_device(Device.loads(wvd))
        cdm_session = cdm.open()
        pssh = PSSH(pssh)
        challenge = cdm.get_license_challenge(cdm_session, pssh)
        license = self.session.post("https://gue1-spclient.spotify.com/widevine-license/v1/audio/license", challenge).content
        cdm.parse_license(cdm_session, license)
        return f'1:{next(i for i in cdm.get_keys(cdm_session) if i.type == "CONTENT").key.hex()}'

    def get_stream_url(self, file_id):
        final = self.session.get(
            f'https://gue1-spclient.spotify.com/storage-resolve/v2/files/audio/interactive/11/{file_id}?version=10000000&product=9&platform=39&alt=json').json()[
            'cdnurl'][0]
        return final

    def decrypt(self, keys, encrypted_location, decrypted_location):
        subprocess.run(
            [
                os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mp4decrypt.exe'),
                encrypted_location,
                '--key',
                keys,
                decrypted_location
            ],
            check=True, creationflags=subprocess.CREATE_NO_WINDOW
        )

    def download(self, encrypted_location, stream_url):
        with YoutubeDL({
            'quiet': True,
            'no_warnings': True,
            'outtmpl': str(encrypted_location),
            'allow_unplayable_formats': True,
            'fixup': 'never',
            'overwrites': False
        }) as ydl:
            ydl.download(stream_url)

    def decrypt(self, keys, encrypted_location, decrypted_location):
        subprocess.run(
            [
                os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mp4decrypt.exe'),
                encrypted_location,
                '--key',
                keys,
                decrypted_location
            ],
            check=True, creationflags=subprocess.CREATE_NO_WINDOW
        )
    def get_encrypted_location(self, track_id):
        return './Cache' + '/' + f'{track_id}_encrypted.mp4'

    def get_decrypted_location(self, track_id):
        return './Cache' + '/' + f'{track_id}_decrypted.mp4'

    def get_fixed_location(self, track_id):
        return './Cache' + '/' + f'{track_id}_fixed.m4a'

    def fixup(self, decrypted_location, fixed_location):
        subprocess.run(
            [
                os.path.join(os.path.dirname(os.path.abspath(__file__)), 'ffmpeg.exe'),
                '-loglevel',
                'error',
                '-y',
                '-i',
                decrypted_location,
                '-c',
                'copy',
                fixed_location
            ],
            check=True, creationflags=subprocess.CREATE_NO_WINDOW
        )

    def make_final(self, fixed_location, final_location, tags):
        file = Path(final_location)
        file.parent.mkdir(parents=True, exist_ok=True)
        shutil.copy(fixed_location, final_location)
        file = MP4(final_location)
        file.clear()
        file.update(tags)
        file.save()



    def start(self, track_id, quality, wvd):
        accountAttributes = self.accountAttributes()
        print(accountAttributes)
        tags = self.get_tags(track_id)
        final_location = self.get_final_location(tags)
        print(final_location)
        file_id = self.audio_extracted(track_id, quality)
        pssh = self.get_pssh(file_id)
        decryption_keys = self.get_decryption_keys(pssh,wvd)
        stream_url = self.get_stream_url(file_id)
        encrypted_location = self.get_encrypted_location(track_id)
        self.download(encrypted_location, stream_url)
        decrypted_location = self.get_decrypted_location(track_id)
        self.decrypt(decryption_keys, encrypted_location, decrypted_location)
        fixed_location = self.get_fixed_location(track_id)
        self.fixup(decrypted_location, fixed_location)
        self.make_final(fixed_location, final_location, tags)
        print('It worked.')


if __name__ == "__main__":
    wvd = b'WVD\x02\x02\...'
    track_id = '5W8YXBz9MTIDyrpYaCg2Ky'
    quality = '128000'
    spotify = SpotifyClient()
    spotify.start(track_id, quality, wvd)

[vijaykrpp]

decr

thanks a lot!! worked!

[yashikada]

I summarized as much as possible to be able to download a song; it can serve as a basis.

I hope someone can transform you code in PR for votify.

[mzilot]

You need to have a cookies.txt file in the same folder and a WVD key. My execution method is in binary form, but you can change the method, and also the files mp4decrypt.exe and ffmpeg.exe. I summarized as much as possible to be able to download a song; it can serve as a basis.

from pathlib import Path
from http.cookiejar import MozillaCookieJar
import requests
import time
import hmac
import hashlib
import math
from mutagen.mp4 import MP4, MP4Cover
from pywidevine import PSSH,Cdm,Device
import subprocess
import os
from yt_dlp import YoutubeDL
import shutil

class TOTP:
def init(self) -> None:
self.secret = b'376136387538459893883312310911992847112448894410210511297108'
self.version = 61
self.period = 30
self.digits = 6

def generate(self, timestamp: int) -> str:
    counter = math.floor(timestamp / 1000 / self.period)
    counter_bytes = counter.to_bytes(8, byteorder="big")

    h = hmac.new(self.secret, counter_bytes, hashlib.sha1)
    hmac_result = h.digest()

    offset = hmac_result[-1] & 0x0F
    binary = (
            (hmac_result[offset] & 0x7F) << 24
            | (hmac_result[offset + 1] & 0xFF) << 16
            | (hmac_result[offset + 2] & 0xFF) << 8
            | (hmac_result[offset + 3] & 0xFF)
    )

    return str(binary % (10 ** self.digits)).zfill(self.digits)

class SpotifyClient:
def init(self):
self.session = requests.Session()
self.clienttoken = None
self.get_session()

def get_session(self):
    totp = TOTP()
    cookies_path = Path("./cookies.txt")

    if cookies_path.exists():
        cookies = MozillaCookieJar(str(cookies_path))
        cookies.load(ignore_discard=True, ignore_expires=True)
        self.session.cookies.update(cookies)

        for cookie in cookies:
            if cookie.name == "sp_t":
                headerssp_t = {
                    "accept": "application/json",
                    "content-type": "application/json",
                    "origin": "https://open.spotify.com/",
                    "referer": "https://open.spotify.com/",
                    "user-agent": "Mozilla/5.0",
                    "spotify-app-version": "1.2.72.240.gf5884949",
                    "app-platform": "WebPlayer",
                    "cookie": f"sp_t={cookie.value};"
                }

                server_time = int(time.time() * 1000)
                generated_totp = totp.generate(server_time)

                session_info = requests.get(
                    "https://open.spotify.com/api/token",
                    params={
                        "reason": "init",
                        "productType": "web-player",
                        "totp": generated_totp,
                        "totpServer": generated_totp,
                        "totpVer": str(totp.version)
                    },
                    headers=headerssp_t
                ).json()

                response = requests.post(
                    "https://clienttoken.spotify.com/v1/clienttoken",
                    json={
                        "client_data": {
                            "client_version": "1.2.72.240.gf5884949",
                            "client_id": session_info["clientId"],
                            "js_sdk_data": {
                                "device_id": cookie.value,
                                "device_type": "computer"
                            }
                        }
                    },
                    headers=headerssp_t
                )

                self.clienttoken = response.json()["granted_token"]["token"]

    self.session.headers.update({
        "accept": "application/json",
        "content-type": "application/json",
        "origin": "https://open.spotify.com/",
        "referer": "https://open.spotify.com/",
        "user-agent": "Mozilla/5.0",
        "spotify-app-version": "1.2.72.240.gf5884949",
        "app-platform": "WebPlayer",
    })

    server_time = int(time.time() * 1000)
    generated_totp = totp.generate(server_time)

    session_info = self.session.get(
        "https://open.spotify.com/api/token",
        params={
            "reason": "init",
            "productType": "web-player",
            "totp": generated_totp,
            "totpServer": generated_totp,
            "totpVer": str(totp.version)
        }
    ).json()
    self.session.headers.update({
        "authorization": f"Bearer {session_info['accessToken']}",
        "client-token": self.clienttoken
    })

def get_track(self, track_id: str) -> dict:
    url = "https://api-partner.spotify.com/pathfinder/v2/query"

    payload = {
        "variables": {
            "uri": f"spotify:track:{track_id}"
        },
        "operationName": "getTrack",
        "extensions": {
            "persistedQuery": {
                "version": 1,
                "sha256Hash": "612585ae06ba435ad26369870deaae23b5c8800a256cd8a57e08eddc25a37294"
            }
        }
    }

    response = self.session.post(
        url,
        json=payload,
    )
    response = response.json()
    return response

def get_tags(self, track):
    album = self.get_track(track)
    track = album['data']['trackUnion']
    album_data = track['albumOfTrack']
    try:
        copyright = next(
            i['text']
            for i in album_data['copyright']['items']
            if i['type'] in ('P', 'C')
        )
    except StopIteration:
        copyright = ''

    date_info = album_data['date']
    if date_info['precision'] == 'YEAR':
        release_date = f"{date_info['year']}-01-01"
    else:
        release_date = date_info['isoString'][:10]

    total_tracks = album_data['tracks']['totalCount']
    total_discs = 1

    artist_name = album['data']['trackUnion']['firstArtist']['items'][0]['profile']['name']

    cover_url = max(
        album_data['coverArt']['sources'],
        key=lambda x: x['width']
    )['url']

    tags = {
        '\xa9nam': [track['name']],
        '\xa9ART': [artist_name],
        'aART': [artist_name],
        '\xa9alb': [album_data['name']],
        'trkn': [(track.get('trackNumber', 1), total_tracks)],
        'disk': [(1, total_discs)],
        '\xa9day': [f'{release_date}T00:00:00Z'],
        'covr': [
            MP4Cover(
                requests.get(cover_url).content,
                imageformat=MP4Cover.FORMAT_JPEG
            )
        ],
        '\xa9cmt': [
            f"https://open.spotify.com/track/{track['uri'].split(':')[-1]}"
        ],
        'cprt': [copyright],
        'rtng': [0],
    }
    return tags

def audio_extracted(self, track, audio_quality):
    metamp4 = self.session.get(f'https://gue1-spclient.spotify.com/track-playback/v1/media/spotify:track:{track}?manifestFileFormat=file_ids_mp4').json()
    audio = next(
        f["file_id"]
        for track in metamp4["media"].values()
        for files in track["item"]["manifest"].values()
        if isinstance(files, list)
        for f in files
        if isinstance(f, dict) and f.get("bitrate") == int(audio_quality)
    )
    return audio

def get_sanizated_string(self, dirty_string, is_folder):
    for character in ['\\', '/', ':', '*', '?', '"', '<', '>', '|', ';']:
        dirty_string = dirty_string.replace(character, '_')
    if is_folder:
        dirty_string = dirty_string[:40]
        if dirty_string[-1:] == '.':
            dirty_string = dirty_string[:-1] + '_'
    else:
        dirty_string = dirty_string[:80]
    return dirty_string.strip()

def get_final_location(self, tags):
    if tags['disk'][0][1] > 1:
        file_name = self.get_sanizated_string(f'{tags["disk"][0][0]} {tags["©nam"][0]}', False) +'.m4a'
    else:
        file_name = self.get_sanizated_string(f'{tags["©nam"][0]}', False) +'.m4a'
    final = './Downloads' + '/' + self.get_sanizated_string(f"{tags['trkn'][0][0]:02d} {tags['aART'][0]}",True) + ' - ' + file_name
    return final

def get_pssh(self, file_id):
    return self.session.get(f'https://seektables.scdn.co/seektable/{file_id}.json').json()['pssh']

def accountAttributes(self):
    url = "https://api-partner.spotify.com/pathfinder/v2/query"
    payload = {
        "variables": {},
        "operationName": "accountAttributes",
        "extensions": {
            "persistedQuery": {
                "version": 1,
                "sha256Hash": "24aaa3057b69fa91492de26841ad199bd0b330ca95817b7a4d6715150de01827"
            }
        }
    }

    response = self.session.post(
        url,
        json=payload,
    )
    account = response.json()['data']['me']['account']['product']
    country = response.json()['data']['me']['account']['country']

    url = "https://api-partner.spotify.com/pathfinder/v2/query"
    payload = {
        "variables": {},
        "operationName": "profileAttributes",
        "extensions": {
            "persistedQuery": {
                "version": 1,
                "sha256Hash": "53bcb064f6cd18c23f752bc324a791194d20df612d8e1239c735144ab0399ced"
            }
        }
    }

    response = self.session.post(
        url,
        json=payload,
    )
    UserName = response.json()['data']['me']['profile']['username']

    mode = 'Country: ' + country + '\n' + 'Account: ' + account + '\n' + 'UserName: ' + UserName+ '\n'
    return mode

def get_decryption_keys(self, pssh, wvd):
    cdm = Cdm.from_device(Device.loads(wvd))
    cdm_session = cdm.open()
    pssh = PSSH(pssh)
    challenge = cdm.get_license_challenge(cdm_session, pssh)
    license = self.session.post("https://gue1-spclient.spotify.com/widevine-license/v1/audio/license", challenge).content
    cdm.parse_license(cdm_session, license)
    return f'1:{next(i for i in cdm.get_keys(cdm_session) if i.type == "CONTENT").key.hex()}'

def get_stream_url(self, file_id):
    final = self.session.get(
        f'https://gue1-spclient.spotify.com/storage-resolve/v2/files/audio/interactive/11/{file_id}?version=10000000&product=9&platform=39&alt=json').json()[
        'cdnurl'][0]
    return final

def decrypt(self, keys, encrypted_location, decrypted_location):
    subprocess.run(
        [
            os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mp4decrypt.exe'),
            encrypted_location,
            '--key',
            keys,
            decrypted_location
        ],
        check=True, creationflags=subprocess.CREATE_NO_WINDOW
    )

def download(self, encrypted_location, stream_url):
    with YoutubeDL({
        'quiet': True,
        'no_warnings': True,
        'outtmpl': str(encrypted_location),
        'allow_unplayable_formats': True,
        'fixup': 'never',
        'overwrites': False
    }) as ydl:
        ydl.download(stream_url)

def decrypt(self, keys, encrypted_location, decrypted_location):
    subprocess.run(
        [
            os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mp4decrypt.exe'),
            encrypted_location,
            '--key',
            keys,
            decrypted_location
        ],
        check=True, creationflags=subprocess.CREATE_NO_WINDOW
    )
def get_encrypted_location(self, track_id):
    return './Cache' + '/' + f'{track_id}_encrypted.mp4'

def get_decrypted_location(self, track_id):
    return './Cache' + '/' + f'{track_id}_decrypted.mp4'

def get_fixed_location(self, track_id):
    return './Cache' + '/' + f'{track_id}_fixed.m4a'

def fixup(self, decrypted_location, fixed_location):
    subprocess.run(
        [
            os.path.join(os.path.dirname(os.path.abspath(__file__)), 'ffmpeg.exe'),
            '-loglevel',
            'error',
            '-y',
            '-i',
            decrypted_location,
            '-c',
            'copy',
            fixed_location
        ],
        check=True, creationflags=subprocess.CREATE_NO_WINDOW
    )

def make_final(self, fixed_location, final_location, tags):
    file = Path(final_location)
    file.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy(fixed_location, final_location)
    file = MP4(final_location)
    file.clear()
    file.update(tags)
    file.save()



def start(self, track_id, quality, wvd):
    accountAttributes = self.accountAttributes()
    print(accountAttributes)
    tags = self.get_tags(track_id)
    final_location = self.get_final_location(tags)
    print(final_location)
    file_id = self.audio_extracted(track_id, quality)
    pssh = self.get_pssh(file_id)
    decryption_keys = self.get_decryption_keys(pssh,wvd)
    stream_url = self.get_stream_url(file_id)
    encrypted_location = self.get_encrypted_location(track_id)
    self.download(encrypted_location, stream_url)
    decrypted_location = self.get_decrypted_location(track_id)
    self.decrypt(decryption_keys, encrypted_location, decrypted_location)
    fixed_location = self.get_fixed_location(track_id)
    self.fixup(decrypted_location, fixed_location)
    self.make_final(fixed_location, final_location, tags)
    print('It worked.')

if name == "main":
wvd = b'WVD\x02\x02...'
track_id = '5W8YXBz9MTIDyrpYaCg2Ky'
quality = '128000'
spotify = SpotifyClient()
spotify.start(track_id, quality, wvd)

In this line:

def get_pssh(self, file_id):
seektable = self.session.get(f'https://seektables.scdn.co/seektable/{file_id}.json')
if seektable.status_code != 200:
#also print status code in text
print(f"{seektable.status_code} PSSH for file ID '{file_id}' not access.")
sys.exit(1)
return seektable.json()['pssh']

Sometimes I get a 403 error for less popular songs, but after playing the song in the browser, I get a 200 response.