Disclaimer

This project is intended for educational and personal use only. The developer does not condone or encourage copyright infringement.

SpotiFLAC-Module-Version is an independent, third-party tool and is not affiliated with, endorsed by, or connected to Spotify, Tidal, Qobuz, Amazon Music, Deezer, or any other streaming service.

You are solely responsible for:

1. Ensuring your use of this software complies with your local laws.
2. Reading and adhering to the Terms of Service of the respective platforms.
3. Any legal consequences resulting from the misuse of this tool.

The software is provided "as is", without warranty of any kind, express or implied. The author assumes no liability for any bans, damages, or legal issues arising from its use or misuse. Users assume all risk associated with its use.

If you are a copyright holder or an authorized representative and believe this repository infringes upon your rights, please contact the maintainer with sufficient detail (including relevant URLs and proof of ownership); the matter will be promptly investigated.

Looking for a standalone app?

• SpotiFLAC (Desktop) — Download music in true lossless FLAC from different providers for Windows, macOS & Linux
• SpotiFLAC (Mobile) — SpotiFLAC for Android & iOS, maintained by @zarzet

Features

• Native synchronous and asynchronous Python APIs
• Modular JavaScript Extension system
• Automatic provider fallback
• Built-in GUI
• Interactive CLI Wizard
• Docker support
• Configuration Profiles
• MusicBrainz metadata enrichment
• Embedded synchronized lyrics
• Optional MP3 320 kbps transcoding

Installation

pip install SpotiFLAC

Quick Start

SpotiFLAC can be used in multiple ways. Choose the mode that fits your needs.

GUI Mode (recommended for most users)

Launch the graphical user interface with the --gui flag:

spotiflac --gui

(Or python launcher.py --gui if running from source)

Interactive Mode (step-by-step wizard)

SpotiFLAC features a smart Interactive Wizard that guides you step-by-step. To launch the wizard, use the --interactive flag:

spotiflac --interactive

(Or python launcher.py --interactive if running from source)

On launch it automatically runs a service health check before asking any questions, so you always know which providers are reachable.

What the wizard does at startup:

• Service Health Check — probes provider endpoints and shows provider availability inline (✅ / ❌) before asking anything
• URL History — shows your last 8 downloads so you can re-run one with a single keypress
• Folder Memory — remembers your last output directory and offers it as the default
• Profile Load — optionally restores a full saved configuration

Smart URL Detection: If you input an Artist URL, it will ask if you want to download "Featuring" tracks. It skips this question for albums or playlists.

Smart File Paths: If you input a Single Track URL, it will ask if you want to set a specific .flac output path. If you do, it intelligently skips all questions about filename formatting and subfolder organization.

Unified Quality Profiles: Automatically translates your desired quality tier across different services (like Tidal and Qobuz).

CLI Generator: At the end of the configuration, it generates and prints the exact CLI command for your specific setup, so you can copy and reuse it in your automated scripts.

Profile Save: After confirming the download, you can save the entire configuration as a named profile to reuse later.

Python API (Synchronous)

The classic synchronous API remains the simplest way to integrate SpotiFLAC into your own applications.

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url="https://open.spotify.com/track/TRACK_ID",
    output_dir="./downloads",
    services=["tidal"],
)

This API is fully backwards-compatible with previous releases and is recommended for scripts and applications that do not require asynchronous execution.

Which API should I use?

Asynchronous API

SpotiFLAC now features a 100% native asynchronous engine, making it ideal for modern Python applications built on asyncio, including:

• Discord bots
• Telegram bots
• FastAPI applications
• Quart / Sanic web servers
• Background workers
• Any asynchronous Python project

The new AsyncSpotiFLAC client uses a shared asynchronous HTTP session, allowing multiple downloads and metadata requests to run efficiently without blocking the event loop.

import asyncio
from SpotiFLAC import AsyncSpotiFLAC

async def main():
    async with AsyncSpotiFLAC(
        output_dir="./downloads",
        services=["tidal", "qobuz"],
        quality="LOSSLESS",
    ) as client:

        # Download a single track
        await client.download_track(
            "https://open.spotify.com/track/TRACK_ID"
        )

        # Fetch playlist metadata without downloading
        info, tracks = await client.get_playlist(
            "https://open.spotify.com/playlist/PLAYLIST_ID"
        )

        print(f"{info['name']} contains {len(tracks)} tracks")

asyncio.run(main())

Why use the async API?

• Fully non-blocking (asyncio native)
• Shared HTTP connection pooling
• Lower memory usage
• Much better performance when downloading multiple tracks concurrently
• Perfect for long-running applications and web backends

Note: The classic synchronous SpotiFLAC() API remains fully supported and backwards-compatible.

JavaScript Extensions

SpotiFLAC supports modular JavaScript extensions originally developed for SpotiFLAC Mobile and now shared across all SpotiFLAC projects.

Extensions can provide alternative implementations for streaming services, allowing SpotiFLAC to continue working even when native APIs change. They are downloaded automatically, kept up to date, and transparently used as fallbacks whenever a native provider fails.

Note: If Node.js is not installed, SpotiFLAC automatically attempts to install it the first time a JavaScript extension is used.

Supported package managers:

• Linux: apt-get, dnf, yum, pacman
• macOS: brew
• Windows: winget, choco

You can also explicitly prioritize an extension:

spotiflac URL ./out \
  --service ext:tidal-web ext:qobuz-web

Extensions use the ext: prefix and behave exactly like native providers. They can be mixed freely:

spotiflac URL ./out \
  --service tidal ext:qobuz-web deezer

Note: Automatic fallback to extensions is enabled by default whenever a native provider for the same service is installed as an extension. Disable it with use_extensions_fallback=False (Python) or --no-extensions-fallback (CLI) if you want SpotiFLAC to use only the explicitly requested providers in services/--service.

Docker Usage & Headless Automation

A lightweight, CLI-focused Docker image is available for running SpotiFLAC on servers, NAS devices, or any headless environment.

Build the Image

docker build -t spotiflac .

Basic Docker Usage

Run a download by mounting local directories to persist your downloads, configuration, cache, and extension registry across container restarts:

docker run --rm -it \
  -v "$(pwd)/downloads:/app/downloads" \
  -v "$(pwd)/.spotiflac_docker:/root/.spotiflac" \
  -v "$(pwd)/.cache_docker:/root/.cache/spotiflac" \
  spotiflac "https://open.spotify.com/track/TRACK_ID" \
  /app/downloads -s deezer -q LOSSLESS

Published Image (GHCR)

Official Docker images are published on GitHub Container Registry (GHCR), allowing you to run the latest version without building locally.

docker pull ghcr.io/bartolomeorusso9/spotiflac-module-version:latest

Logs in Headless Environments

A progress bar is a stream of carriage returns: readable on a terminal, unreadable in a log file. docker logs collapses each refresh into a [285B blob data] line, which buries everything worth reading.

SpotiFLAC therefore draws animated bars only when stderr is an interactive terminal. Everywhere else — Docker, cron, a redirected file — it prints the same information as plain lines instead:

[RUN] 24 track(s) · tidal, qobuz · LOSSLESS · 2 in parallel → /app/downloads
Track [3/24] Track Title — Artist Name (Album Name)
  ⬇  Track Title  ·  47%  ·  13.4 MB / 28.4 MB
  ✓  Track Title  ·  TIDAL  ·  FLAC  ·  28.4 MB  ·  12s

Progress lines are throttled to at most one per 25% and per 10 seconds, so a track costs a handful of lines rather than one per received chunk.

Set SPOTIFLAC_PROGRESS_BARS to override the detection in either direction:

export SPOTIFLAC_PROGRESS_BARS=0   # never draw bars, even on a terminal
export SPOTIFLAC_PROGRESS_BARS=1   # always draw bars

Supported URL Types

SpotiFLAC supports the following URL formats for Spotify, Tidal, Apple Music, SoundCloud, YouTube and Pandora:

Note: SoundCloud and YouTube tracks are downloaded as MP3 (neither platform distributes lossless audio). Apple Music downloads as M4A/ALAC (lossless) or AAC depending on the selected quality. Pandora downloads as MP3 (mp3_192 by default) or M4A (aac_64 / aac_32). All other services deliver FLAC.

Joox, NetEase, Migu and Kuwo are download-only services — they cannot be used as input URL sources. Use a Spotify or Tidal link and set one of these as the service. These providers are primarily available in select Asian markets and may require a VPN outside those regions.

SoundCloud short links (on.soundcloud.com/...) and mobile links (m.soundcloud.com/...) are automatically resolved. Tracking parameters (e.g. ?utm_source=...) are stripped before processing.

Apple Music track links with an ?i= song parameter (e.g. music.apple.com/us/album/album-name/id?i=trackid) are also supported.

Pandora app links (pandora.app.link/...) are automatically resolved to their canonical web URL. Pandora pretty URLs (e.g. pandora.com/artist/artist-name/album-name/song-name/TR:...) are fully supported.

Advanced Configuration

You can customize the download behavior, prioritize specific streaming services, and organize your files automatically into folders.

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url="https://open.spotify.com/album/ALBUM_ID",
    output_dir="./MusicLibrary",
    services=["qobuz", "amazon", "tidal"],
    filename_format="{year} - {album}/{track}. {title}",
    use_artist_subfolders=True,
    use_album_subfolders=True,
    loop=60,                     # retry duration in minutes
    track_max_retries=2,         # extra per-track retries on failure
    post_download_action="notify"
)

Service Health Check

SpotiFLAC can probe all provider endpoints before downloading to verify which ones are currently reachable.

In Interactive Mode this runs automatically at startup. In code or scripts you can call it directly:

from SpotiFLAC.core.health_check import (
    run_health_check,
    print_health_report,
    get_working_providers,
)

results = run_health_check(["tidal", "qobuz", "deezer", "soundcloud", "pandora"])
print_health_report(results)

working = get_working_providers(results)
print("Available providers:", working)

# CLI: check all services then download
spotiflac https://open.spotify.com/track/... ./out --service tidal qobuz

The health check runs in parallel with a configurable timeout (default: 5 s per endpoint) and never blocks your download if a check fails. In the GUI, the check reports provider-level availability and endpoint counts, without exposing individual raw endpoint URLs.

Configuration Profiles

Save and reuse complete download configurations without re-typing them every time.

Save a profile

# Save current flags as "hires-tidal"
spotiflac https://... ./out \
  --service tidal \
  --quality HI_RES_LOSSLESS \
  --use-album-subfolders \
  --filename-format "{year} - {album}/{track}. {title}" \
  --save-profile hires-tidal

Load a profile

# Load "hires-tidal" — flags override profile values when both are present
spotiflac https://... ./out --profile hires-tidal

In Python

import asyncio
from SpotiFLAC.core.profiles import (
    save_profile_async,
    get_profile_async,
    list_profiles_async,
)

async def main():
    await save_profile_async("hires-tidal", {
        "services":             ["tidal"],
        "quality":              "HI_RES_LOSSLESS",
        "use_album_subfolders": True,
        "filename_format":      "{year} - {album}/{track}. {title}",
    })

    cfg = await get_profile_async("hires-tidal")
    print(await list_profiles_async())  # ['hires-tidal']

asyncio.run(main())

Profiles are stored at ~/.cache/spotiflac/profiles.json. In the Interactive Wizard, you are prompted to load a profile at startup and optionally save one at the end.

Batch Downloads

Pass a list of URLs to download them all in sequence. Failed tracks per URL are collected and can be retried with loop.

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url=[
        "https://open.spotify.com/album/ALBUM_ID",
        "https://open.spotify.com/playlist/PLAYLIST_ID",
        "https://listen.tidal.com/album/ALBUM_ID",
    ],
    output_dir="./MusicLibrary",
    services=["tidal", "qobuz"],
    use_album_subfolders=True,
)

Auto-Retry on Failure

Set track_max_retries (Python) or --retries (CLI) to automatically retry failed tracks. Each retry cycles through all configured providers from the beginning, waiting exponentially longer between attempts (2 s → 4 s → 8 s …, capped at 30 s).

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url="https://open.spotify.com/album/...",
    output_dir="./downloads",
    services=["tidal", "qobuz", "deezer"],
    track_max_retries=3,   # up to 3 extra attempts per track
)

spotiflac https://open.spotify.com/album/... ./out \
  --service tidal qobuz deezer \
  --retries 3

Tip: Combine --retries with --loop for maximum resilience — --retries handles transient errors on individual tracks, while --loop re-queues permanently failed tracks after N minutes.

Per-Track Timeout

Set timeout_s (Python) or --timeout (CLI) to cap the time SpotiFLAC will spend downloading a single track. If the download does not complete within the specified number of seconds, the process is terminated and the track is marked as failed — allowing the next provider or retry to take over.

# CLI — skip any track that takes more than 3 minutes
spotiflac https://open.spotify.com/album/... ./out --service tidal --timeout 180

# Python API
from SpotiFLAC import SpotiFLAC
SpotiFLAC(
    url="https://open.spotify.com/album/...",
    output_dir="./downloads",
    services=["tidal", "qobuz"],
    timeout_s=120,
)

Tip: Pair --timeout with --retries so that a stalled track is automatically re-attempted against the next provider instead of blocking the entire queue indefinitely.

MP3 Transcoding

Downloads always fetch the best source a provider offers (FLAC, ALAC/M4A, …). Set transcode_to="mp3" (Python) or --mp3 / --transcode mp3 (CLI) to convert every finished track to MP3 — 320 kbps by default — for players or car stereos that cannot handle lossless files. Tags, cover art and lyrics are carried over to the MP3, and the original file is deleted once the conversion succeeds unless transcode_keep_original / --keep-original is set.

Requires ffmpeg on your PATH: the run stops immediately with a clear error if it is missing, so you never download a whole album only to fail at the conversion step.

# CLI — every track ends up as a 320 kbps MP3
spotiflac https://open.spotify.com/album/... ./out --service tidal --mp3

# Keep the FLAC too, and use 192 kbps instead
spotiflac https://open.spotify.com/album/... ./out --mp3 --transcode-bitrate 192k --keep-original

# Python API
from SpotiFLAC import SpotiFLAC
SpotiFLAC(
    url="https://open.spotify.com/album/...",
    output_dir="./downloads",
    services=["tidal", "qobuz"],
    transcode_to="mp3",
    transcode_bitrate="320k",
)

Skipping already-downloaded tracks still works. The converted file keeps the exact name the provider would have used, only with an .mp3 extension, so SpotiFLAC looks for that file before contacting any provider and skips the track when it is already there — no network request, no re-encode. Running the same album twice therefore costs nothing the second time. A leftover file from an earlier lossless run is converted in place instead of being re-downloaded, so an existing library converges to MP3 in a single pass.

The conversion is a no-op for providers that already deliver MP3 (e.g. SoundCloud), which are passed through untouched.

Multiple Playlists in One Folder

Pass --playlist (-p) once per playlist to sync several of them into a single destination folder. Repeat the flag as many times as you need — the last positional argument is the destination:

spotiflac -p https://open.spotify.com/playlist/AAA \
          -p https://open.spotify.com/playlist/BBB \
          -p https://open.spotify.com/playlist/CCC \
          ./Music --service tidal

• One copy per track. A song that appears in three of those playlists is downloaded once. Tracks are matched by ISRC (resolved automatically when the metadata lacks it), falling back to artist + title, so the same recording pulled from different playlists is recognised even when the catalogue ids differ.
• Nothing already on disk is downloaded again. The destination folder is indexed before any provider is contacted, in any audio format — a track already there as .m4a is not re-fetched just because this run would produce a .flac.
• One M3U per playlist. Each playlist gets a <Playlist Name>.m3u8 file in the destination folder listing its own tracks, in playlist order, with paths relative to the folder — so the whole directory stays portable and can be copied to a phone or a USB stick as is. Two playlists sharing a name get Name.m3u8 and Name (2).m3u8.
• Cheap to re-run. Playlist files are rewritten only when their content actually changed. Running the same command again after a playlist gained a track downloads that one track and touches that one M3U file.

Tracks that failed to download are left out of the playlist file, so it always lists files that really exist; they are picked up on the next run.

Everything else keeps working as usual — --mp3, --filename-format, --service, --retries and friends all apply:

# Sync three playlists as 320 kbps MP3, writing classic .m3u files
spotiflac -p URL1 -p URL2 -p URL3 ./Music --mp3 --m3u m3u

With --mp3 a playlist entry points at the converted file, and a track already present as MP3 is skipped without any network request. Use --m3u none to merge the playlists into one folder without writing playlist files at all.

Note: avoid --use-track-numbers (and {position} in --filename-format) here: the number depends on the merged playlist order, so filenames would change whenever any playlist does — and previously downloaded tracks would be fetched again under the new name. SpotiFLAC warns when you do.

Post-Download Actions

SpotiFLAC(url="...", output_dir="./downloads", post_download_action="open_folder")

SpotiFLAC(url="...", output_dir="./downloads",
          post_download_action="command",
          post_download_command="rsync -av '{folder}/' user@nas:/music/")

spotiflac https://... ./out --post-action notify
spotiflac https://... ./out --post-action command --post-command "rsync -av '{folder}/' user@nas:/music/"

Note: Wrap {folder} in single quotes in your command template (e.g. '{folder}') to safely handle spaces and most special characters. Single quotes do not protect against an apostrophe (') inside the output path itself — avoid apostrophes in output_dir, or escape them manually for your shell before running the command.

Discography Download

Download the complete discography of an artist. Duplicate tracks (same ISRC across different releases) are automatically skipped.

from SpotiFLAC import SpotiFLAC

# Spotify — albums + singles
SpotiFLAC(url="https://open.spotify.com/artist/ARTIST_ID", output_dir="./MusicLibrary",
          services=["qobuz", "tidal"], use_album_subfolders=True, filename_format="{year} - {album}/{track}. {title}")

# Tidal — full discography (append /discography/albums or /discography/singles to filter)
SpotiFLAC(url="https://listen.tidal.com/artist/ARTIST_ID", output_dir="./MusicLibrary",
          services=["tidal"], use_album_subfolders=True, filename_format="{year} - {album}/{track}. {title}")

spotiflac https://open.spotify.com/artist/... ./MusicLibrary \
  --service tidal --include-featuring \
  --use-album-subfolders --filename-format "{year} - {album}/{track}. {title}"

Recommended layout: --use-album-subfolders + --filename-format "{year} - {album}/{track}. {title}".

Custom Output Path (single tracks)

For single track downloads you can specify the exact file path instead of relying on output_dir + filename_format.

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url="https://open.spotify.com/track/TRACK_ID",
    output_dir="./downloads",
    output_path="files/song.flac"
)

Note: output_path is automatically ignored when the URL points to an album, playlist, or artist/discography.

Qobuz Local API URL (Optional)

By default, SpotiFLAC attempts Qobuz requests anonymously, without any local API configured. For improved reliability, reduced rate limits, and to use your own Qobuz subscription credentials instead of anonymous access, you can deploy a self-hosted Qobuz stream API and point SpotiFLAC to it.

How to deploy your own instance: github.com/BartolomeoRusso9/qobuz-rest-api

Note: Self-hosting requires your own valid Qobuz account and is subject to Qobuz's Terms of Service. You are responsible for ensuring your use complies with those terms and with applicable law in your jurisdiction.

How to apply the Qobuz Local API URL in SpotiFLAC:

• Interactive Wizard: The wizard prompts you to enter your local Qobuz API URL during configuration.
• Environment Variable:

export QOBUZ_LOCAL_API_URL="https://localhost:8000"

• Python:

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url="URL",
    output_dir="./downloads",
    qobuz_local_api_url="https://localhost:8000",
)

• config.json:

{
    "qobuz_local_api_url": "https://localhost:8000"
}

Custom Tidal API Instance (Optional)

By default, SpotiFLAC connects to a shared pool of public hifi-api mirrors to fetch Tidal streams. For guaranteed availability, full control, and to use your own Tidal Premium credentials instead of relying on third-party mirrors, you can self-host your own instance and point SpotiFLAC to it — it will always be tried first, before any public mirror.

How to deploy your own instance: github.com/binimum/hifi-api

Note: Self-hosting requires your own valid Tidal account and is subject to Tidal's Terms of Service. You are responsible for ensuring your use complies with those terms and with applicable law in your jurisdiction.

Python

from SpotiFLAC import SpotiFLAC

SpotiFLAC(
    url="https://open.spotify.com/track/TRACK_ID",
    output_dir="./downloads",
    services=["tidal"],
    tidal_custom_api="https://your-instance.example.com",
)

CLI

spotiflac https://open.spotify.com/track/... ./downloads \
  --service tidal \
  --tidal-api "https://your-instance.example.com"

Interactive Wizard

The wizard prompts for a custom Tidal API URL at step 12.5, right after the optional tokens section.

config.json

{
    "tidal_custom_api": "https://your-instance.example.com"
}

Note: The custom instance is also saved and restored when using --save-profile / --profile.

CLI Usage (standalone executables)

./SpotiFLAC-Windows.exe url
                        output_dir
                        [--service tidal qobuz deezer amazon soundcloud youtube apple pandora joox netease migu kuwo]
                        [--filename-format "{title} - {artist}"]
                        [--output-path "files/song.flac"]
                        [--quality LOSSLESS]
                        [--use-track-numbers]
                        [--use-album-track-numbers]
                        [--use-artist-subfolders]
                        [--use-album-subfolders]
                        [--first-artist-only]
                        [--qobuz-local-api URL]
                        [--tidal-api URL]
                        [--timeout seconds]
                        [--loop minutes]
                        [--no-extensions-fallback]
                        [--verbose]
                        [--no-lyrics]
                        [--lyrics-providers spotify apple musixmatch amazon lrclib]
                        [--no-enrich]
                        [--enrich-providers deezer apple qobuz tidal soundcloud]
                        [--retries N]
                        [--post-action none|open_folder|notify|command]
                        [--post-command "CMD with {folder} {succeeded} {failed}"]
                        [--profile NAME]
                        [--save-profile NAME]

chmod +x SpotiFLAC-Linux-arm64
./SpotiFLAC-Linux-arm64 url
                        output_dir
                        [--service tidal qobuz deezer amazon soundcloud youtube apple pandora joox netease migu kuwo]
                        [--filename-format "{title} - {artist}"]
                        [--output-path "files/song.flac"]
                        [--quality LOSSLESS]
                        [--use-track-numbers]
                        [--use-album-track-numbers]
                        [--use-artist-subfolders]
                        [--use-album-subfolders]
                        [--first-artist-only]
                        [--qobuz-local-api URL]
                        [--tidal-api URL]
                        [--timeout seconds]
                        [--loop minutes]
                        [--no-extensions-fallback]
                        [--verbose]
                        [--no-lyrics]
                        [--lyrics-providers spotify apple musixmatch amazon lrclib]
                        [--no-enrich]
                        [--enrich-providers deezer apple qobuz tidal soundcloud]
                        [--retries N]
                        [--post-action none|open_folder|notify|command]
                        [--post-command "CMD with {folder} {succeeded} {failed}"]
                        [--profile NAME]
                        [--save-profile NAME]

(For ARM devices like Raspberry Pi, replace x86_64 with arm64)

API Reference

SpotiFLAC() Parameters

Filename Format Placeholders

When customizing the filename_format string, you can use the following dynamic tags:

• {title} — Track title
• {artist} — Track artist(s)
• {album} — Album name
• {album_artist} — The artist(s) of the entire album
• {disc} — The disc number
• {track} — The track's original number in the album
• {position} — Download queue / playlist position (zero-padded, e.g. 01)
• {date} — Full release date (e.g., YYYY-MM-DD)
• {year} — Release year (e.g., YYYY)
• {isrc} — Track ISRC code

CLI Flag Reference

MusicBrainz Enrichment

SpotiFLAC automatically queries MusicBrainz in the background (when an ISRC is available) while the audio is being downloaded, adding professional-grade tags at no extra time cost. Fields written when found:

Download Validation

After each download, SpotiFLAC validates the file to detect common issues:

• Preview detection — if the expected duration is ≥ 60 s but the downloaded file is ≤ 35 s, the file is deleted and the download is retried with the next provider.
• Duration mismatch — for tracks longer than 90 s, a deviation greater than 25% (or 15 s minimum) from the expected duration is treated as a corrupt download and the file is removed.

Want to support the project?

If this software is useful and brings you value, consider supporting the project by buying us a coffee. Your support helps keep development going.

API Credits

Song.link · hifi-api · qobuz-rest-api · dabmusic.xyz · GD Studio Music API · Music Wjhe API · afkarxyz · MusicBrainz · SoundCloud · Apple Music · YouTube Music · Pandora · squid.wtf · flacdownloader.com · monochrome · spotiflacapp · anandprtp · Deezer · Amazon Music · Tidal · LRCLIB · Musixmatch · Songstats · Soundplate · iTunes Search API · Cobalt

[!TIP] Star the repo to show support, and click Watch → Custom → Releases on GitHub if you want to be notified as soon as a new release goes out.