# spotify-mcp: a Spotify MCP server for Claude and other MCP clients

> spotify-mcp connects an MCP client such as Claude Desktop or Cursor to Spotify playback, search and playlist management. It runs through uvx or a local clone, needs Spotify Premium, and the README now calls the project inactive.

**varunneal/spotify-mcp** — MCP to connect your LLM with Spotify.

- Repository: https://github.com/varunneal/spotify-mcp
- Stars: 614 · Forks: 133
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/varunneal-spotify-mcp

## What spotify-mcp does and who it is for

spotify-mcp is an MCP server that exposes Spotify actions as tools an LLM client can call. The README lists the surface: start, pause and skip playback, search for tracks, albums, artists and playlists, fetch info about each of those, manage the queue, and manage, create and update playlists. It is built on top of spotipy, pinned at 2.26.0 in pyproject.toml, and the package itself is version 0.2.0 with requires-python >=3.12.

The audience is narrow on purpose. You need an MCP-enabled client such as Claude Desktop or Cursor, and the troubleshooting section states you need Spotify Premium because the developer API requires it. If you want a music recommendation engine, this is not it: the README's TODO section says a batch of recommendation features were deprecated from the Spotify API, so most remaining work is minor or maintenance. The project is a control plane for playback and library operations, not a discovery tool.

## How the MCP server talks to Spotify

The architecture is a single Python entry point registered as spotify-mcp in pyproject.toml, pointing at spotify_mcp:main. The server starts under an MCP client, reads three environment variables (SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET, SPOTIFY_REDIRECT_URI), and uses spotipy to call the Spotify Web API on your behalf. Tool calls arrive from the LLM, the server translates them into spotipy calls, and results go back to the client.

Authentication is the part that shapes the whole setup. You register an app at developer.spotify.com with a redirect URI, and the README requires that URI to use http with an explicit loopback address, IPv4 or IPv6, with http://127.0.0.1:8080/callback as the example. The README also warns that you may have to restart your MCP environment once or twice before it works, which tells you the OAuth handshake is the fragile step rather than the tool logic. Logs go to stderr as the MCP spec requires; on macOS the README points to ~/Library/Logs/Claude, and elsewhere to the MCP quickstart page on getting logs from Claude for Desktop.

## Installing spotify-mcp with uvx and adding it to your MCP config

The README's first path is uvx, which runs the server straight from the Git repository. Add this block to your MCP config, replacing the two credential placeholders with the values from your Spotify developer dashboard:

```json
{
  "mcpServers": {
    "spotify": {
      "command": "uvx",
      "args": [
        "--python", "3.12",
        "--from", "git+https://github.com/varunneal/spotify-mcp",
        "spotify-mcp"
      ],
      "env": {
        "SPOTIFY_CLIENT_ID": YOUR_CLIENT_ID,
        "SPOTIFY_CLIENT_SECRET": YOUR_CLIENT_SECRET,
        "SPOTIFY_REDIRECT_URI": "http://127.0.0.1:8080/callback"
      }
    }
  }
}
```

Before that, create an app on the Spotify developer dashboard with http://127.0.0.1:8080/callback as the redirect URI. The README says any port works as long as it is http on an explicit loopback address. Then locate the client config: on macOS Claude Desktop reads ~/Library/Application\ Support/Claude/claude_desktop_config.json, and on Windows %APPDATA%/Claude/claude_desktop_config.json. Restart the client, and if the Spotify tools do not appear, restart it again; the README notes this may be necessary once or twice.

The README flags one cost of the uvx route: it opens the Spotify redirect URI for every tool call. If that interrupts you, clone the repository instead:

```bash
git clone https://github.com/varunneal/spotify-mcp.git
```

Then point the config at the checkout with the uv run form, using the --directory argument and the same three environment variables. The README adds that a local clone may need chmod -R 755 to enable execution permissions, and that uv should be version 0.54 or newer. For debugging, the README gives the MCP Inspector command:

```bash
npx @modelcontextprotocol/inspector uv --directory /path/to/spotify-mcp run spotify-mcp
```

The Inspector prints a URL you open in a browser to exercise tools outside the chat client.

## Where spotify-mcp breaks down or is the wrong choice

The README's own March 2026 notice says the project is inactive and most PRs will not be merged, so treat the tool list as frozen. The TODO section names tests as outstanding, which means there is no test suite to lean on when you change the code or upgrade spotipy. Paginated search results, playlists and albums are also listed as not yet supported, so a search that returns more items than one page will not be walked for you.

Two constraints come from outside the repository. Spotify Premium is required, so free accounts are out. And the deprecated recommendation endpoints mean the features people most often imagine when they hear "LLM plus Spotify" are not available through this server at all. If your goal is generating playlists from taste profiles, this project gives you the CRUD pieces and leaves the ranking logic to the model.

The OAuth flow is the practical failure mode. Because the redirect URI must be http on a loopback address and the uvx mode reopens it per tool call, a misconfigured port or a non-loopback hostname will fail before any Spotify call happens. The README's advice to restart the MCP environment once or twice is a symptom of that, not a fix.

## Alternatives and how their approach differs

The search terms around this project include other Spotify MCP servers, and the README itself points at the underlying library: spotipy, the Python client this server wraps. If you want full control over which Spotify endpoints are exposed, calling spotipy directly from your own script is the lower-level route. You write the OAuth handling and the tool schemas yourself, and you get pagination and any endpoint spotipy supports, but you also own the maintenance that this project has stopped doing.

A hosted or packaged Spotify MCP server takes the opposite trade. You skip the local clone, the chmod step and the uv version check, and in exchange you hand your Spotify credentials to someone else's process. The README's local-clone instructions exist precisely so the credentials and the OAuth redirect stay on your machine. That is the real difference to weigh: convenience of setup against where the client secret lives.

## Maintenance, licence and upgrade cost

The last push to the default branch was on 2026-03-11, and the README carries a March 2026 notice stating the project is inactive and most PRs will not be merged. Plan for the code you clone to be the code you keep. Dependencies are pinned tightly in pyproject.toml: mcp==1.3.0 and spotipy==2.26.0, with python-dotenv>=1.0.1 and Python >=3.12. Tight pins slow bit rot but also mean moving to a newer MCP or spotipy release is your edit to make.

The licence is MIT, which permits commercial and private use and modification provided the copyright notice and permission notice are included. That is a statement about the repository metadata, not legal advice; if you redistribute the server inside a product, have your own counsel read the MIT text in LICENSE. There are no retrieved releases, so upgrades arrive as commits rather than versioned artifacts, and version 0.2.0 in pyproject.toml is the only version marker visible.

## Conclusion

Adopt spotify-mcp if you already run an MCP client, have Spotify Premium, and want playback control and search rather than recommendation features. Do not adopt it if you need paginated search results, tests, or a project that merges pull requests, because the README states the project is inactive and most PRs will not be merged. Before wiring it into a daily workflow, verify the redirect URI you registered is http on an explicit loopback address, and check whether the uvx setup opens the redirect URI on every tool call in your client, since the README notes the local clone exists to avoid that.

## FAQ

### Is there a spotify-mcp server for Claude?

Yes. The README describes an MCP project to connect Claude with Spotify, and gives a config block for Claude Desktop on macOS and Windows. It exposes playback, search, queue and playlist tools to the client.

### Can I use Spotify in Claude with spotify-mcp?

The README's setup adds spotify-mcp to your MCP config and requires Spotify API keys plus Spotify Premium for the developer API. The README notes you may need to restart the MCP environment once or twice before it works.

### Is there a spotify-mcp server?

Yes, spotify-mcp is an MCP server distributed through the repository and run either with uvx from git or from a local clone with uv. It is version 0.2.0 and requires Python 3.12 or newer.

### Does the spotify-mcp server support streaming?

The README does not describe streaming. It lists start, pause and skip playback, search, info lookups, queue management, and playlist management as the available features.

## Sources

- [Issues](https://github.com/varunneal/spotify-mcp/issues)
- [License: MIT](https://github.com/varunneal/spotify-mcp/blob/main/LICENSE)
- [README](https://github.com/varunneal/spotify-mcp/blob/main/README.md)
- [varunneal/spotify-mcp on GitHub](https://github.com/varunneal/spotify-mcp)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/varunneal-spotify-mcp