Verifying Artist Names in MP3 Files Using the Last.fm API with Python

In this article, we will be verifying artist names in MP3 files using the Last.fm API with Python. We will explore how to design and implement a Python script that scans directories and sub-directories for MP3 files, extracts artist names from the file's metadata, and verifies their accuracy using the Last.fm API. By the end of this article, you will have a powerful tool at your disposal to ensure the correctness of artist names in your MP3 collection.

pip install eyed3
pip install requests

import os
import requests
import eyed3

LASTFM_API_KEY = '<YOUR_LASTFM_API_KEY>'


def get_correct_artist_name(artist_name, track_title):
    """
    Retrieves the correct artist name for a given track title using the Last.fm API.
    :param artist_name: The artist name from the MP3 file.
    :param track_title: The track title from the MP3 file.
    :return: The correct artist name from the Last.fm API or None if not found.
    """
    url = f'http://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key={LASTFM_API_KEY}&artist={artist_name}&track={track_title}&format=json'
    response = requests.get(url)
    data = response.json()
    if 'track' in data and 'artist' in data['track']:
        return data['track']['artist']['name']
    return None


def scan_directory(directory):
    """
    Scans a directory and its sub-directories for MP3 files and checks the artist names using the Last.fm API.
    :param directory: The directory to scan.
    """
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.endswith('.mp3'):
                file_path = os.path.join(root, file)
                audio = eyed3.load(file_path)
                if audio and audio.tag:
                    artist_name = audio.tag.artist
                    if artist_name:
                        correct_artist_name = get_correct_artist_name(artist_name, audio.tag.title)
                        if correct_artist_name and artist_name.lower() != correct_artist_name.lower():
                            print(f'Incorrect Artist Name: {artist_name}')
                            print(f'Correct Artist Name: {correct_artist_name}')
                            print(f'File Location: {file_path}')
                            print()


if __name__ == "__main__":
    # Specify the directory to scan for MP3 files
    directory_to_scan = '/path/to/your/directory'
    scan_directory(directory_to_scan)

The code begins by importing the necessary libraries: os, requests, and eyed3. It then defines the LASTFM_API_KEY constant with your Last.fm API key.

The get_correct_artist_name() function constructs a URL using the artist name, track title, and Last.fm API key. It makes a request to the Last.fm API and retrieves the correct artist name from the response. The function returns the correct artist name if found or None otherwise.

The scan_directory() function takes a directory path as a parameter and uses the os.walk() function to traverse the directory and its sub-directories. It looks for files with the .mp3 extension and loads their metadata using eyed3. It extracts the artist name from the metadata and calls get_correct_artist_name() to verify it. If the retrieved artist name is different from the one in the file, it prints the incorrect artist name, correct artist name, and file location.

In the if __name__ == “__main__”: block, you can specify the directory you want to scan for MP3 files by assigning the directory path to the directory_to_scan variable. Make sure to replace ‘/path/to/your/directory' with the actual directory path.

Handling API Responses

When the Last.fm API responds to our requests, we need to process the response and retrieve the correct artist name. The get_correct_artist_name() function handles this by parsing the JSON response and extracting the necessary information. It checks if the response contains the track and artist keys and returns the corresponding artist name. If the artist's name is not found, it returns None.

To compare the retrieved artist name with the one in the file, we convert both names to lowercase using the lower() method. This ensures a case-insensitive comparison.

Testing the Application

To demonstrate the usage of our script, let's assume we have a directory called “Music” containing various sub-directories with MP3 files. We want to verify the artist names in those files. Here's an example directory structure:

Music/
├── Pop/
│   ├── song1.mp3
│   ├── song2.mp3
│   └── song3.mp3
├── Rock/
│   ├── song4.mp3
│   ├── song5.mp3
│   └── song6.mp3
└── Jazz/
    ├── song7.mp3
    ├── song8.mp3
    └── song9.mp3

Bonus Section: Automatically Updating Metadata and Filename

In addition to verifying artist names, we can further enhance the functionality of our script by automatically updating the metadata and filename with the correct information retrieved from the Last.fm API. This bonus section will guide you through the modifications required to incorporate this additional functionality.

To achieve this, we will utilize the eyed3 library, which provides convenient methods for manipulating MP3 metadata. We will extend our existing scan_directory() function to update the metadata and filename if the artist name needs correction. Here's the modified code:

import os
import requests
import eyed3

LASTFM_API_KEY = '<YOUR_LASTFM_API_KEY>'


def get_correct_artist_name(artist_name, track_title):
    """
    Retrieves the correct artist name for a given track title using the Last.fm API.
    :param artist_name: The artist name from the MP3 file.
    :param track_title: The track title from the MP3 file.
    :return: The correct artist name from the Last.fm API or None if not found.
    """
    url = f'http://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key={LASTFM_API_KEY}&artist={artist_name}&track={track_title}&format=json'
    response = requests.get(url)
    data = response.json()
    if 'track' in data and 'artist' in data['track']:
        return data['track']['artist']['name']
    return None


def scan_directory(directory):
    """
    Scans a directory and its sub-directories for MP3 files, checks the artist names using the Last.fm API,
    and updates the metadata and filename if needed.
    :param directory: The directory to scan.
    """
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.endswith('.mp3'):
                file_path = os.path.join(root, file)
                audio = eyed3.load(file_path)
                if audio and audio.tag:
                    artist_name = audio.tag.artist
                    if artist_name:
                        correct_artist_name = get_correct_artist_name(artist_name, audio.tag.title)
                        if correct_artist_name and artist_name.lower() != correct_artist_name.lower():
                            print(f'Incorrect Artist Name: {artist_name}')
                            print(f'Correct Artist Name: {correct_artist_name}')
                            print(f'File Location: {file_path}')
                            print()

                            # Update metadata and filename
                            audio.tag.artist = correct_artist_name
                            audio.tag.save()

                            # Update filename
                            new_filename = f'{correct_artist_name} - {audio.tag.title}.mp3'
                            new_file_path = os.path.join(root, new_filename)
                            os.rename(file_path, new_file_path)
                            print(f'Updated Metadata and Filename: {new_filename}')
                            print()


if __name__ == "__main__":
    # Specify the directory to scan for MP3 files
    directory_to_scan = '/path/to/your/directory'
    scan_directory(directory_to_scan)

In this updated code, after identifying an incorrect artist name, we proceed to update the metadata and filename. First, we modify the artist attribute of the audio.tag object to the correct artist name. Next, we save the modified metadata using audio.tag.save(), which updates the MP3 file with the corrected artist name. Finally, we rename the file by constructing a new filename in the format <correct_artist_name> – <track_title>.mp3 and using os.rename() to rename the file accordingly.

By incorporating this bonus functionality, our script not only identifies and displays incorrect artist names but also automatically updates the metadata and filename for a more streamlined and organized music library.

Feel free to customize the code further based on your specific requirements, such as handling edge cases or logging the changes made. Enjoy the enhanced automation and accuracy in managing your music collection!

Conclusion

In this comprehensive guide, we explored how to verify artist names in MP3 files using the Last.fm API with Python. We started by understanding the importance of accurate artist information in music collections and identified the need for an automated solution to verify and update artist names. We then designed and implemented a Python script that scans directories and sub-directories for MP3 files, extracts artist names from metadata, and leverages the Last.fm API for verification. Furthermore, we added a bonus functionality to automatically update metadata and filenames with the correct information.

By utilizing Python and the Last.fm API, this script empowers music enthusiasts, DJs, and digital music library managers to maintain accurate and consistent artist information effortlessly. It streamlines the process of verifying and updating artist names, saving valuable time and effort. Whether you have a vast music collection, curate playlists, create DJ sets, or manage a professional music library, this script provides a powerful tool to enhance your music organization workflow.

As you further customize and enhance the script, you can adapt it to your specific needs. Consider adding additional checks, incorporating logging capabilities, or integrating it into a broader music management system. Python's flexibility allows for endless possibilities to tailor the script to your unique requirements.

Now it's time for you to put this knowledge into action. Start by implementing the script, and witness how it efficiently verifies and updates artist names in your MP3 files. Embrace the benefits of an accurate and organized music library, ensuring a seamless music experience every time you browse, search, or play your favorite tracks.

Happy scripting and enjoy your enhanced music organization journey!