Mit der Web API ermöglicht es Spotify sowohl Informationen rund um Songs (im Folgenden Tracks genannt, da dies im englischen Sprachgebrauch üblich ist und dies somit auch bei der API der korrekte Begriff ist), Artisten und Playlisten „auslesen“. Ebenso kann man auch, sofern ein Spotify-Nutzer deiner App dies erlaubt, bspw. Änderungen an Playlisten etc. vornehmen. In diesem Beitrag zeige ich an funktionierenden Code-Beispielen, wie man die Spotify Web API mit Python nutzen kann.
Wie erhält man mit Python für die Spotify Web API einen access token? Wie erhält man zu einem Spotify-Nutzer für gewisse scopes den authorization code mit Python? Wie erhält man mit Python für einen Spotify-Nutzer einen access token? Diese Fragen beantworte ich in diesem Beitrag anhand von kurzen Python-Codebeispielen!
Inhaltsverzeichnis
Voraussetzungen für den Zugriff auf die Spotify Web API
Damit man die Web API von Spotify überhaupt nutzen kann, benötigt man einen Developer-Account bei Spotify (developer.spotify.com), eine eigene App im Spotify-Ökosystem, sowie für diese App die geheimen Zugangsdaten Client ID und Client secret.
Wenn du diesen Beitrag liest, wirst du vermutlich bereits über alles zuvor genannte Verfügen, so dass ich mir die Erklärung erspare, wie du alles einrichtest. Meiner Meinung nach, ist dies auch sehr simple und ziemlich selbsterklärend!
In meinem konkreten Beispiel werden wir die Spotify Web API mit Python nutzen. Ich nutze hierfür Python 3.8!
Unterschiedliche API-Zugriffe für Spotify
Für die Spotify Web API gibt es im Wesentlich zwei unterschiedliche Anmeldeverfahren. Wenn man nichts im Namen eines Spotify-Nutzers machen möchte, sondern Dinge für Informationen über Tracks oder Artisten auslesen möchte, genügt die Anmeldung mit der Client ID und dem Client secret (und dem Bearer aka access token).
Sobald man aber Dinge im Namen eines Spotify-Nutzers tun möchte, benötigt man zusätzlich abgesicherte Rechte, welche auch zeitlich begrenzt sind. Im Folgenden beschreibe ich hier wie man den Authorization code mit Python umsetzen kann.
Beim Authorization code benötigt man von einem Spotify-User die explizite Erlaubnis Dinge im Namen des Spotify-Users tun zu dürfen. Da man mit der eigenen Anwendung also als ein anderer Spotify-User agieren kann, ist dieser Zugriff aufwändiger abgesichert, als der Zugriff lediglich über die Client credentials.
Ich beschreibe also beides: Zugriff auf die Spotify Web API mit Client credentials und über Authorization code.
Python-Zugriff auf die Spotify Web API mit Client credentials
Wir haben mit unserem Spotify Developer Account eine eigene App angelegt und für diese sowohl die Client ID, als auch das Client secret. Um nun auf Informationen über Tracks bspw. zugreifen zu können, benötigen wir noch einen Access token. Den Spotify access token erhalten wir gegen Vorlage von Client ID und Client secret. Mit Python kann das wie folgt aussehen:
import requests, base64, json
#preparing request - replace clientID & clientSecret
api = "https://accounts.spotify.com/api/token"
headers = {}
data = {}
credentials = f"clientID:clientSecret"
credentialsBytes = credentials.encode('ascii')
credentialsBase64 = base64.b64encode(credentialsBytes)
finalCredentials = credentialsBase64.decode('ascii')
headers['Authorization'] = f"Basic {finalCredentials}"
data['grant_type'] = "client_credentials"
#getting the spotify API token
token_response = requests.post(api, headers=headers, data=data)
token = token_response.json()['access_token']
Alles, was du an diesem Code-Beispiel anpassen musst um deinen access token für die Spotify Web API zu erhalten, sind clientID und clientSecret in der Zeile 7. Führst du den Python-Code aus, erhältst du als Ergebnis deinen access token mit der Variable token.
Mit diesem access token für die Spotify Web API kannst du nun nahezu unendliche Informationen zu Tracks, Artisten oder Alben von Spotify auslesen. Ich zeige dir nun, wie wir zu einem Suchbegriff die Spotify track id erhalten. Die track id ist ein eindeutiger Identifier für jeden Song auf Spotify (also mehr oder weniger sowas wie ein Kennzeichen beim Auto).
import requests, json
query = "track:YourTrackName%20artist:Your%20artist&type=track&market=DE"
songURL = f"https://api.spotify.com/v1/search?q={query}"
headers = {
#token is the Spotify API token you retrieved earlier
"Authorization": "Bearer " + token
}
res = requests.get(url=songURL, headers=headers)
tmp=res.json()
if int(tmp['tracks']['total']) > 0:
track_id=tmp['tracks']['items'][0]['id']
print(track_id)
else:
print("No matching result(s)")
Zu dem Code-Beispiel folgende Anmerkungen:
- In Zeile 7 kommt die Variable token vor, welche den access token aus dem Code-Beispiel zuvor enthält!
- In Zeile 3 musst du die query an deine Suchanfrage anpassen, also alles nach track: und artist: für deinen Bedarf anpassen. Der query-String muss hierbei „urlencoded“ sein, darf also keine Leerzeichen etc. in der regulären Schreibweise enthalten.
Sofern es mindestens einen Treffe für deine Suchanfrage gibt, wird int(tmp[‚tracks‘][‚total‘]) >0 sein und die track id verbirgt sicht hinter tmp[‚tracks‘][‚items‘][0][‚id‘]
Möchte man über die Spotify Web API Dinge im Namen eines Spotify-Users ausführen, muss man den Authorization Code Flow von Spotify befolgen. Grob skizziert bedeutet dieser folgendes:
- Ein Spotify-User berechtigt deine App in dessen Namen gewisse Dinge (scope) auf Spotify zu tun. Hierfür erhalten wir für diesen Spotify-User einen authorization code.
- Mit diesem authorization code, unserer Client ID, unserem Client secret dem grant_type und der für unsere App hinterlegten redirect_uri erfragen wir dann den access token und refresh token. Der access token hat immer nur eine Gültigkeit von 60 Minuten und muss dann über den refresh token erneuert werden!
- Mit dem access token für den Spotify-User können wir dann die gemäß scope vom Spotify-User erlaubten Dinge im Namen dieses Spotify-Users ausführen.
Aber der Reihe nach 🙂
Den authorization code von/für einen Spotify-User erhält man nur, wenn dieser Spotify-User den von deiner App angefragten Berechtigungen explizit zustimmt. Diese Zustimmung kann man am einfachsten mittels URL-Aufruf im Browser erfragen.
Ich erkläre das Vorgehen im Folgenden so, dass du es mit deinem eigenen Spotify-User testen kannst. Für andere User kannst du dieses Beispiel nicht 1:1 nutzen, da du die redirect_uri anpassen und hier natürlich noch einen „Empfänger“ für den Code bauen musst, damit du den kompletten workflow zum Erhalt des authorization code umsetzen kannst.
Die URL kann dann wie folgt aussehen, wobei du natürlich CLIENTID, die redirect_uri und die gewünschten Berechtigungen (scope) anpassen musst:
https://accounts.spotify.com/de/authorize?client_id=CLIENTID&response_type=code&redirect_uri=http%3A%2F%2Flocalhost%3A3000&scope=playlist-modify-public%2Cplaylist-modify-private
Beachte beim Generieren der URL, dass diese wieder urlencoded sein muss! Welche Berechtigungen es gibt und was diese konkret bedeuten, erfährst du ausführlich in der Dokumentation von Spotify. In meinem Beispiel erfragen wir die Berechtigung Playlisten (private und öffentliche) des Users verändern zu dürfen.
Die als URL-Parameter angegebene redirect_uri muss mit der von dir für deine App bei Spotify hinterlegte Redirect URI übereinstimmen!
Rufst du mit deinem Spotify-Account die von dir für deinen Zweck angepasste URL auf und gewährst deiner App die erfragten Berechtigungen, wirst du auf http://localhost:3000 weitergeleitet, da dies die redirect_uri ist, was zu einem 404 führen dürfte. Als Parameter erhältst du aber dennoch den gewünschten authorization code übergeben, also sowas wie http://localhost:3000/?code=AQA…. (mit sehr vielen weiteren Buchstaben und Zahlen).
Diesen Authorization code merken wir uns nun für deinen Spotify-User. Nur für deinen Spotify-User ist dieser Authorization code gültig und nutzbar! Jeder andere Spotify-User wird einen anderen Authorization code erhalten!
Mit dem zuvor erhaltenen authorization token sowie unserer ClientID und dem Client secret erfragen wir nun einen access token und einen refresh token. Den refresh token benötigen wir, da der access token für den Zugriff auf den Account eines Spotify-Users immer nur 60 Minuten Gültigkeit hat.
Mit Python kann der Code hierfür wie folgt aussehen:
from requests import post
import base64
code="YOUR-CODE-HERE"
REDIRECT_URI="" #whatever you whitelistet on Spotify for your app
credentials = f"clientID:clientSecret"
credentialsBytes = credentials.encode('ascii')
credentialsBase64 = base64.b64encode(credentialsBytes)
finalCredentials = credentialsBase64.decode('ascii')
token_data = {
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': REDIRECT_URI
}
token_header = {
'Authorization': f'Basic {finalCredentials}',
'Content-Type': 'application/x-www-form-urlencoded'
}
response = post('https://accounts.spotify.com/api/token', data=token_data, headers=token_header)
print(response)
access_token = response.json()['access_token']
refresh_token = response.json()['refresh_token']
#access-token is valid for 60 minutes
print("access_token:",access_token)
#use refreh-token to get a new access-token
print("refresh_token:",refresh_token)
Die Zeilen 4, 5 und 7 musst du mit deinen Daten füllen. Als Ergebnis solltest du dann den access_token sowie refresh_token für deinen eigenen Spotify-User erhalten.
Der refresh_token wird langfristig benötigt um den immer nur für 60 Minuten gültigen access token zu aktualisieren. Bei jeder Aktualisierung ändert sich der access token zu einem Spotify-User!
Mit Python über die Spotify Web API einen Song zu einer Playlist hinzufügen
Nun haben wir uns alles benötigte „erarbeitet“ um beispielsweise einen Song zu der Playlist eines Spotify-Users hinzufügen zu können, sofern dieser uns, also unser App hierfür die Berechtigung gewährt hat.
access_token="USER_ACCESS_TOKEN"
track_id="TRACKID"
playlist_id="PLAYLISTID"
songList="spotify:track:"+track_id
#add song to playlist
URL = f'https://api.spotify.com/v1/playlists/{playlist_id}/tracks?uris={songList}'
response = requests.post(
URL,
headers={
"Accept": "application/json",
"Content-Type": "application/json",
"Authorization": "Bearer " + access_token
})
response_json = response.json()
print(response_json)
Wenn alles geklappt hat, gibt uns Spotify als response in etwa folgendes zurück:
{’snapshot_id‘: ‚MTgsNmY4ZTYxNzExYjIxMTE2NDM1MWY1ZmI1ZWQ4ZmVkNjsagasghY2MzMA==‘}
Rufst du in Spotify selbst die für den Request genutzte Playlist auf, sollte der Song mit der genutzten track id nun in der Playlist enthalten sein.
Produktempfehlungen
