-
-
Save TheMuellenator/c84616c21f0f9ce68c12c357d3e1c794 to your computer and use it in GitHub Desktop.
| sp = spotipy.Spotify( | |
| auth_manager=SpotifyOAuth( | |
| scope="playlist-modify-private", | |
| redirect_uri="http://example.com", | |
| client_id=YOUR UNIQUE CLIENT ID, | |
| client_secret= YOUR UNIQUE CLIENT SECRET, | |
| show_dialog=True, | |
| cache_path="token.txt" | |
| ) | |
| ) | |
| user_id = sp.current_user()["id"] | |
| date = input("Which year do you want to travel to? Type the date in this format YYYY-MM-DD: ") | |
| song_uris = ["The list of", "song URIs", "you got by", "searching Spotify"] | |
| playlist = sp.user_playlist_create(user=user_id, name=f"{date} Billboard 100", public=False) | |
| # print(playlist) | |
| sp.playlist_add_items(playlist_id=playlist["id"], items=song_uris) |
To add the tracks to the playlist I used another spotipy method, I can't find the one in the solution in the documentation. According to PyCharm that method also doesn't exist. Here is my code I used:
``
import requests
from bs4 import BeautifulSoup
import spotipy
from spotipy.oauth2 import SpotifyOAuth
import os
from dotenv import load_dotenv
load_dotenv()
BILLBOARD_ENDPOINT= "https://www.billboard.com/charts/hot-100/"
BILLBOARD_HEADER = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0"}
# entered a fixed date for testing purposes
# date = input("Which year do you want to travel to? Type the date in this format YYYY-MM-DD:")
date = "2022-12-12"
response = requests.get(url=f"{BILLBOARD_ENDPOINT}{date}",headers=BILLBOARD_HEADER)
soup = BeautifulSoup(response.text, "html.parser")
songs = soup.find_all(name="h3", class_="c-title a-no-trucate a-font-primary-bold-s u-letter-spacing-0021 lrv-u-font-size-18@tablet lrv-u-font-size-16 u-line-height-125 u-line-height-normal@mobile-max a-truncate-ellipsis u-max-width-330 u-max-width-230@tablet-only")
top_100_songs = []
for song in songs:
title = song.getText().strip()
top_100_songs.append(title)
sp = spotipy.Spotify(
auth_manager=SpotifyOAuth(
scope="playlist-modify-private",
redirect_uri="http://example.com",
client_id=os.environ["SPOTIPY_CLIENT_ID"],
client_secret=os.environ["SPOTIPY_CLIENT_SECRET"],
show_dialog=True,
cache_path="token.txt",
username="***********"
)
)
user_id = sp.current_user()["id"]
track_uri_list = []
for song in top_100_songs:
search = sp.search(q=song,type="track")
try:
track_uri_list.append(search["tracks"]["items"][0]["uri"])
except IndexError:
print("Track not found")
playlist_name = f"{date} Billboard 100"
playlist = sp.user_playlist_create(user_id, playlist_name, public=False, description=f"Billboard top 10 from {date}")
playlist_id = playlist["id"]
print(f"playlist created with id {playlist_id}")
sp.user_playlist_add_tracks(user=user_id, playlist_id=playlist_id, tracks=track_uri_list)
print("tracks added")
``
This is going to be my first comment ever in any course I've ever done. If You are struggling, please use this code, it has error handling, it has log it has prints, I went freaked out and went all over hahaha:
import requests
from bs4 import BeautifulSoup
import spotipy
from spotipy.oauth2 import SpotifyOAuth
from spotipy.exceptions import SpotifyException
import logging
import time
Spotify credentials
SPOTIFY_CLIENT_SECRET = "YOURSECRET"
SPOTIFY_CLIENT_ID = "YOURID"
iN SPOTIFY I USED THE MAC URL OF MY PC WITH PORT 3000 for the authorization
REDIRECT_URI = "http://127.0.0.1:3000"
--- Logging Setup ---
logging.basicConfig(
filename='playlist_log.txt',
filemode='a',
format='%(asctime)s - %(levelname)s - %(message)s',
level=logging.INFO
)
--- Get User Input ---
date = input("Enter the date (YYYY-MM-DD): ")
playlist_name = input("Enter a name for your Spotify playlist: ")
logging.info(f"User input date: {date}, playlist name: {playlist_name}")
--- Billboard Scraper ---
def get_billboard_hot_100(date):
url = f"https://www.billboard.com/charts/hot-100/{date}"
headers = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/114.0.0.0 Safari/537.36"
)
}
try:
response = requests.get(url, headers=headers, timeout=10)
response.raise_for_status()
except requests.exceptions.HTTPError as e:
logging.error(f"HTTP Error while accessing Billboard: {e}")
print(f"❌ Billboard page returned {response.status_code}. Try another date.")
return []
except requests.exceptions.RequestException as e:
logging.error(f"Request failed: {e}")
print("❌ Failed to fetch Billboard page.")
return []
soup = BeautifulSoup(response.text, "html.parser")
songs = []
# Billboard class sets
target_classes = {
'c-title', 'a-no-trucate', 'a-font-primary-bold-s',
'u-letter-spacing-0021', 'lrv-u-font-size-18@tablet',
'lrv-u-font-size-16', 'u-line-height-125',
'u-line-height-normal@mobile-max', 'a-truncate-ellipsis',
'u-max-width-330', 'u-max-width-230@tablet-only'
}
target_classes_top = {
'c-title', 'a-no-trucate', 'a-font-primary-bold-s',
'u-letter-spacing-0021', 'u-font-size-23@tablet',
'lrv-u-font-size-16', 'u-line-height-125',
'u-line-height-normal@mobile-max', 'a-truncate-ellipsis',
'u-max-width-245', 'u-max-width-230@tablet-only',
'u-letter-spacing-0028@tablet'
}
def class_matcher(tag, class_set):
return (
tag.name == "h3" and
tag.get("class") and
set(tag.get("class")).issuperset(class_set)
)
# Top 1 song using lambda to match the exact classes
try:
top_tag = soup.find(lambda tag: class_matcher(tag, target_classes_top))
if top_tag:
top_title = top_tag.get_text(strip=True)
top_artist_tag = top_tag.find_parent("li").find("span", class_="c-label")
top_artist = top_artist_tag.get_text(strip=True) if top_artist_tag else "Various Artists"
songs.append((top_title, top_artist))
except Exception as e:
logging.warning(f"Failed to parse top song: {e}")
# Songs 2–100
try:
all_h3s = soup.find_all(lambda tag: class_matcher(tag, target_classes))
for tag in all_h3s:
title = tag.get_text(strip=True)
artist_tag = tag.find_parent("li").find("span", class_="c-label")
artist = artist_tag.get_text(strip=True) if artist_tag else "Various Artists"
songs.append((title, artist))
except Exception as e:
logging.error(f"Failed to parse song list: {e}")
return songs
--- Spotify Authentication ---
try:
sp = spotipy.Spotify(auth_manager=SpotifyOAuth(
client_id=SPOTIFY_CLIENT_ID,
client_secret=SPOTIFY_CLIENT_SECRET,
redirect_uri=REDIRECT_URI,
scope="playlist-modify-private"
))
user_id = sp.current_user()["id"]
except SpotifyException as e:
logging.critical(f"Spotify authentication failed: {e}")
print("❌ Spotify login failed. Check credentials or scope.")
exit(1)
--- Fetch Songs ---
try:
songs = get_billboard_hot_100(date)
logging.info(f"Fetched {len(songs)} songs from Billboard.")
except Exception as e:
logging.critical(f"Unexpected error fetching Billboard songs: {e}")
print("❌ Something went wrong getting Billboard data.")
exit(1)
if not songs:
print("
exit()
--- Search Spotify for Songs ---
track_uris = []
for title, artist in songs:
query = f"{title} {artist}"
try:
result = sp.search(q=query, type="track", limit=1)
items = result["tracks"]["items"]
if items:
uri = items[0]["uri"]
track_uris.append(uri)
print(f"✅ Found: {title} by {artist}")
else:
logging.warning(f"❌ Not found: {title} by {artist}")
except SpotifyException as e:
logging.error(f"Spotify search failed for '{query}': {e}")
continue
time.sleep(0.2) # prevent rate limiting
--- Create Playlist and Add Tracks ---
if track_uris:
try:
playlist = sp.user_playlist_create(user=user_id, name=playlist_name, public=False)
sp.playlist_add_items(playlist_id=playlist["id"], items=track_uris)
print(f"\n🎉 Playlist '{playlist_name}' created with {len(track_uris)} tracks!")
logging.info(f"Playlist '{playlist_name}' created with {len(track_uris)} tracks.")
except SpotifyException as e:
logging.error(f"Failed to create playlist or add songs: {e}")
print("❌ Playlist creation or track addition failed.")
else:
print("\n
logging.warning("No Spotify tracks found; playlist not created.")
I have added few more features:
- get the list of playlists in a user profile
- check if there is an empty playlist and if yes, get its 'id'
- if no playlists exist or if no empty playlists exist, create a new playlist and get its id
- time taken to execute the program completely
This way we can have new playlist on every run.
Note: Spotify takes some time to report the proper track count in a playlist. So, if you create a new empty playlist, add some songs to it, and immediately run the code again, the previously created playlist will be reported as empty. I think it takes roughly 15sec to get the updated count.
`
GOAL - to create a spotify playlist of top 100 songs on billboard.com on a selected day
import requests
from bs4 import BeautifulSoup
import time
import spotipy
from spotipy.oauth2 import SpotifyOAuth
import pprint
spotify_client_id = "..."
spotify_client_secret = "..."
spotify_redirect_uri = "https://example.com/"
def get_top_100_titles(selected_date) -> list:
"""
Fetches the top 100 titles for a selected date from billboard.com and returns
:return: list of top 100 titles
"""
print(f"Getting top 100 titles on {selected_date} from billboard...")
header = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0"}
billboard_url = "https://www.billboard.com/charts/hot-100/" + selected_date.strip()
response = requests.get(url=billboard_url, headers=header)
response.raise_for_status()
website = response.text
soup = BeautifulSoup(website, "html.parser")
# list_items = soup.find_all(name="li", class_="o-chart-results-list__item")
list_items = soup.select("li ul li h3")
titles = [item.string.strip() for item in list_items]
# for item in list_items:
# title_h3 = item.find(name="h3", attrs={"class":"c-title"})
# if title_h3:
# titles.append(title_h3.string.strip())
return titles
def write_data(selected_date, data: list) -> None:
"""
Writes the data to a text file
:param selected_date: user selected date
:param data: list
:return: None
"""
print("Adding the top 100 songs to the file...")
with open("top_100.txt", "w") as file:
file.write(f"{selected_date}\n")
for i in range(len(data)):
file.write(f"{i + 1}. {data[i]}\n")
def humanize_time(seconds) -> None:
intervals = [("d", 86400), ("h", 3600), ("m", 60)]
parts = []
if seconds:
for label, count in intervals:
value, seconds = divmod(seconds, count)
if value:
parts.append(f"{value:.0f}{label}")
parts.append(f"{seconds:.02f}s")
print(" ".join(parts))
def add_to_playlist(date, titles_to_add):
print("Authenticating with Spotify...")
# steps to add the title to the user's spotify playlist
# 1. get client_id, client_secret from spotify
# 2. get authorization token from spotify using spotipy
# spotify authorization
# playlist-modify-private
# scope = "user-library-read"
scope = "playlist-modify-public"
sp = spotipy.Spotify(auth_manager=SpotifyOAuth(scope=scope, client_id=spotify_client_id,
client_secret=spotify_client_secret, redirect_uri=spotify_redirect_uri, show_dialog=True, cache_path="token.txt", username="vgst cof"))
user_id = sp.current_user()["id"]
# 3. get an empty playlist id from spotify
# get the list of playlists in a user profile
print("Fetching list of playlists...")
playlist_search_results = sp.current_user_playlists()["items"]
# check if there are any empty playlists and get its id
empty_playlist_id = None
if playlist_search_results:
print(f"{len(playlist_search_results)} playlists exist")
# there are playlists in the user profile
for playlist in playlist_search_results:
no_of_tracks = int(playlist["tracks"]["total"])
if not no_of_tracks:
print(no_of_tracks)
empty_playlist_id = playlist["id"]
empty_playlist_name = playlist["name"]
print(f"Empty playlist name: {empty_playlist_name}")
break
if not playlist_search_results or not empty_playlist_id:
print("No playlists or no empty playlists exist, creating a new playlist...")
# if there are no playlists or if there are no empty playlists, create a new playlist
new_empty_playlist = sp.user_playlist_create(user=user_id, name=f"Top 100 {date}")
empty_playlist_id = new_empty_playlist["id"]
empty_playlist_name = new_empty_playlist["name"]
print(f"New empty playlist name: {empty_playlist_name}")
# 4. get the id of the title
print("Adding tracks to the the playlist", end="")
titles_with_ids = []
for title in titles_to_add:
print(".", end="")
search_results = sp.search(q="track:" + title, type="track")["tracks"]["items"]
if search_results:
# if the title exists in spotify db
title_id = search_results[0]["id"]
titles_with_ids.append(title_id)
else:
print(title, "does not exist in Spotify. Skipped.")
# 5. add the title to the user's playlist
sp.playlist_add_items(playlist_id=empty_playlist_id, items=titles_with_ids)
#--------------------#--------------------#
get the date from the user
user_chosen_date = input("Which year do you want to travel to? Type the date in YYYY-MM-DD: ")
to track the time for program execution
start_t = time.time()
get the top 100 songs/titles for the selected date
top_100_titles = get_top_100_titles(user_chosen_date)
if top_100_titles:
# write the titles to a text file
write_data(user_chosen_date, top_100_titles)
# add tracks to the user's playlist
add_to_playlist(user_chosen_date, top_100_titles)
end_t = time.time()
humanize_time(end_t - start_t)
`
import requests, spotipy, os
from dotenv import load_dotenv
from spotipy.oauth2 import SpotifyOAuth
load_dotenv()
class SpotifyManager:
def __init__(self):
self._user=os.environ["SPOTIFY_CLIENT_ID"]
self._password=os.environ["SPOTIFY_CLIENT_SECRET"]
self._sp = self._create_object()
self._user_id = self._get_user_id()
self.song_names = []
self.song_artists = []
self.track_uris = []
self.results = []
def _create_object(self):
return spotipy.Spotify(
auth_manager=SpotifyOAuth(
scope="playlist-modify-private",
redirect_uri="https://example.com",
client_id=self._user,
client_secret=self._password,
cache_path="token.txt",
username=""
)
)
def _get_user_id(self):
return self._sp.current_user()['id']
def create_top100_playlist(self, date):
self.get_track_uris(self.song_names)
self.add_tracks_playlist(self.create_playlist(date))
def create_playlist(self, date):
new_playlist = self._sp.user_playlist_create(
user=self._user_id,
name=f"Top 100 on {date}",
public=False,
description=f"Billboard Top 100 Playlist from {date}"
)
return new_playlist['id']
def get_track_uris(self, songs):
for song in songs:
result = self._sp.search(q=song, type='track', limit=10)
self.results.append(result)
try:
uri = result['tracks']['items'][0]['uri']
self.track_uris.append(uri)
except IndexError:
print(f"{song} doesn't exist in Spotify. Skipped")
def add_tracks_playlist(self, playlist_id):
self._sp.user_playlist_add_tracks(user=self._user_id, playlist_id=playlist_id, tracks=self.track_uris)import requests, spotipy, os
from bs4 import BeautifulSoup
from dotenv import load_dotenv
from data_manager import SpotifyManager
load_dotenv()
spotifymanager = SpotifyManager()
date = input("Which year do you want to travel to? Type the year in this format YYYY-MM-DD: ")
URL="https://www.billboard.com/charts/hot-100/"
header = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15"
}
response = requests.get(url=f"{URL}{date}", headers=header)
soup = BeautifulSoup(response.text, "html.parser")
song_names_spans = soup.select("li ul li h3")
spotifymanager.song_names = [song.getText().strip() for song in song_names_spans]
song_artist_spans = soup.select("li ul li h3+span")
spotifymanager.song_artists = [artist.getText().strip() for artist in song_artist_spans]
spotifymanager.create_top100_playlist(date)It took a bit because the documentation isn't the greatest for Spotipy, but after doing everything based on Spotify API, I used the Spotipy package and got it solved.
Hello Developers,
import requests
from bs4 import BeautifulSoup
import spotipy
from spotipy.oauth2 import SpotifyOAuth
import json
Note: Set Up a Spotify Developer Account
Go to the Spotify Developer Dashboard.
Log in and create a new app.
Note down the Client ID and Client Secret.
Set the Redirect URI (e.g., http://localhost:8888/callback or https://example.com).
Constants
CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"
REDIRECT_URI = "https://example.com" # I used this.
SPOTIFY_SCOPE = "playlist-modify-private"
date = input("Which year do you want to travel to? Type the date in this format YYYY-MM-DD: ")
URL = f"https://billboard.com/charts/hot-100/{date}/" # Dynamic URL
URL = "https://www.billboard.com/charts/hot-100/2000-08-12" # Constant URL for the testing
header = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0"}
response = requests.get(url = URL, headers=header)
website_data = response.text
soup = BeautifulSoup(website_data, "html.parser")
Get the Song name of top 100 list
song_names = [name.getText().strip() for name in soup.select("li ul li h3")]
print(song_names)
Authenticate
sp = spotipy.Spotify(
auth_manager=SpotifyOAuth(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
redirect_uri=REDIRECT_URI,
scope=SPOTIFY_SCOPE))
user-library-read
user_id = sp.current_user()["id"]
print(user_id)
Create Playlist
playlist = sp.user_playlist_create(user=user_id, name=f"{date} Billboard 100", public=False, description=f"{date} Billboard 100")
print(playlist)
Get the song uri to add into the playlist tracks
song_uris = []
for song in song_names:
result = sp.search(q=song) # type = dictionary to get data.
try:
# print(json.dumps(result, sort_keys=4, indent=4)) # this is to identify the song url
uri = result["tracks"]["items"][0]["uri"]
song_uris.append(uri)
except IndexError:
print(f"{song} doesn't exist in Spotify. Skipped.")
Add songs into playlist
sp.playlist_add_items(playlist_id=playlist['id'], items=song_uris)
print("Tracks added to the playlist!")
It feels too difficult for me right now. :(
I find it hard to fully understand the Spotify library documentation.
However, I will try to follow the example code you provided, and later I will give it another attempt.
Yes, the documentation is vast, and it's not readily available to understand the concepts.
Please post your question on the code I posted. I can try to clarify the same to you.
Thanks!
I'm so happy that I was able to finish this project. There might be some problems on the solution due to some system update but glad that I was able to solve it through the help of the people here. Thank you so much.
The solutions I did are:
- The redirect URI should be "https://open.spotify.com/" not "'https://example.com/", and should also match the redirect URI on your Dashboard App URI
- I changed the scope from "playlist-modify-private" to "playlist-modify-private playlist-modify-public". There should be two scopes added.
- When the "Enter the URL you are directed:" pop up on your console, copy the whole URL to which you are directed. It won't appear the second time you run your code again.
Here's my code. Hope it helps:
import export
import requests
from bs4 import BeautifulSoup
import spotipy
from spotipy.oauth2 import SpotifyOAuth
date = input("Which year do you want to travel to? Type the date in this format YYYY-MM-DD: ")
url = f'https://www.billboard.com/charts/hot-100/{date}/'
headers = {'user-agent': 'your own user agent'}
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text,'html.parser')
song_names_spans = soup.select("li ul li h3")
song_names = [song.getText().strip() for song in song_names_spans]
print(song_names)
REDIRECT_URI = "https://open.spotify.com/"
sp = spotipy.Spotify(
auth_manager=SpotifyOAuth(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
redirect_uri=REDIRECT_URI,
cache_path="token.txt",
scope="playlist-modify-private playlist-modify-public"))
year_input = date.split("-")[0]
song_uris = []
for song in song_names:
search_requests = sp.search(q=f"track:{song} year:{year_input}")
try:
uri = search_requests["tracks"]["items"][0]["uri"]
song_uris.append(uri)
except IndexError:
print(f"\n{song} does not exist in Spotify. Skipped...\n")
user_id = sp.current_user()["id"]
playlist = sp.user_playlist_create(user=user_id,
name=f"{date} Billboard 100",
public=False,
description=f"Top 100 songs on {date}")
sp.playlist_add_items(playlist_id=playlist["id"], items=song_uris)
Good to hear, ChaVarilla!
Happy Learning!
As of October 2025, this code is working as attended for everyone reference
import requests
from bs4 import BeautifulSoup
import spotipy
from spotipy.oauth2 import SpotifyOAuth
import os
from dotenv import load_dotenv
load_dotenv()
user_input = input('Which year do you want to travel to? Type the date in this format YYYY-MM-DD: ')
headers = {'User-Agent': 'MY USER AGENT'}
site_html = requests.get(f'https://www.billboard.com/charts/hot-100/{user_input}/', headers=headers).text
soup = BeautifulSoup(site_html, features='html.parser')
top_100 = soup.select('li ul li h3')
top_100_list = [songs.text.strip().replace('\n', '').replace('\t', '') for songs in top_100]
#print(top_100_list)
sp = spotipy.Spotify(
auth_manager=SpotifyOAuth(
client_id=os.getenv('SPOTIFY_CLIENT_ID'),
client_secret=os.getenv('SPOTIFY_CLIENT_SECRET'),
scope='playlist-modify-private',
cache_path='token.txt',
redirect_uri='http://127.0.0.1:9090',
show_dialog=True,
username='g35k',
))
user_id = sp.current_user()["id"]
song_uris = []
year = user_input.split('-')[0]
print(year)
for song in top_100_list:
result = sp.search(q=f'track:{song} year:{year}', type='track')
print(result)
try:
uri=result['tracks']['items'][0]['uri']
song_uris.append(uri)
except IndexError:
print(f'{song} not found')
playlist = sp.user_playlist_create(user=user_id, name=f'{user_input} Billboard 100', public=False)
sp.playlist_add_items(playlist_id=playlist['id'], `items=song_uris)```
I believe struggling to understand the API document is a benefit, Learning happen best when struggling lol.
I had to add very specified search criteria when fetching information from Billboard site:
v-- I also had issue creating the playlist to Spotify. Code below resolved my issue, thank you @grizzleswens ! --v