spotify-mcp
Allows interaction with the Spotify Web API to retrieve a user's listening history, top artists and tracks, recently played items, playlists, artist profiles, and search the catalog.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@spotify-mcpHow has my music taste changed this year?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
spotify-mcp
An MCP server that lets AI assistants answer questions about your Spotify listening history.
Ask "how has my taste changed this year?" in Claude and get a real answer, computed from your actual listening data — not a guess.
> How has my music taste changed over the past year?
# Taste evolution (top 30 artists per window)
## Rising — in the last 4 weeks but not the last year
Phoenix, Men I Trust, Jungle, Rex Orange County
## Fading — in the last year but not the last 4 weeks
Radiohead, Kendrick Lamar, Fleetwood Mac, Interpol, Portishead
## Constant — present in both
Tame Impala, Frank Ocean, Daft Punk, The Strokes
Overlap between the 4-week and 1-year windows: 11/30 artists.Example output. The tool reports whatever your own account contains.
Built on the Model Context Protocol, an open standard — so one server works in Claude Desktop, Claude Code, Cursor, or any other MCP client, with no integration code written per client.
Read-only. Every granted scope is a *-read scope: the server can observe
your account and cannot modify it. No playback control, no playlist edits.
Tools
Tool | Question it answers |
| "What am I into lately?" — top artists and tracks for a 4-week, 6-month, or 1-year window |
| "How has my taste changed?" — who's rising, fading, and constant across all three windows |
| "What have I had on?" — recent plays, repeat artists, time-of-day pattern |
| Your playlists, with track counts |
| "What is this playlist?" — dominant artists, how varied it is, release decades, runtime |
| An artist's albums and singles, newest first |
| Search tracks, artists, or albums |
| What's playing right now |
Tools are designed around questions rather than API endpoints. taste_evolution
makes three API calls and diffs them server-side, because Spotify exposes three
fixed windows and no history — returning an answer rather than three pages of
raw JSON for the model to reconcile itself.
Related MCP server: Spotify MCP Node Server
Requirements
Node.js 20.12 or newer
A Spotify account
A free Spotify developer app (below) — no paid tier needed
Setup
1. Install
git clone https://github.com/sjtan2302/spotify-mcp.git
cd spotify-mcp
npm install
npm run build2. Create a Spotify app
Go to the Spotify developer dashboard and click Create app.
Field | Value |
App name | Anything, e.g. |
App description | Required; anything, e.g. |
Website | Leave blank |
Redirect URI |
|
Which API/SDKs | Check Web API |
Two things that trip people up:
Click "Add" before "Save". The redirect URI is silently dropped otherwise, and the resulting error looks like an invalid client ID.
Use
127.0.0.1, notlocalhost. Spotify disallowedlocalhosthostnames in February 2025;http://localhost:8888/callbackis rejected withINVALID_CLIENT: Insecure redirect URI.
Then open the app's Settings and copy the Client ID.
3. Add your Client ID
cp .env.example .envPut the ID in .env:
SPOTIFY_CLIENT_ID=your_client_id_hereNo client secret is needed. This server uses OAuth 2.0 with PKCE, which exists precisely so that no secret has to be stored. The Client ID is not sensitive.
4. Authorize
npm run loginA browser opens; approve the request. Tokens are written to
~/.spotify-mcp/tokens.json with 0600 permissions, and refreshed
automatically from then on. You only do this once.
5. Verify
npm run smokeThis launches the server the way a real client does and exercises every tool against your account.
Connecting an AI assistant
Claude Desktop
Edit ~/Library/Application Support/Claude/claude_desktop_config.json
(macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"spotify": {
"command": "/usr/local/bin/node",
"args": ["/absolute/path/to/spotify-mcp/dist/index.js"]
}
}
}Then fully quit and reopen Claude Desktop — it only reads this file at launch.
Use the absolute path to
node(which node). Claude Desktop does not inherit your shellPATH, and a bare"node"is the most common reason a server silently fails to start.
Claude Code
claude mcp add spotify -- node /absolute/path/to/spotify-mcp/dist/index.jsThe server locates .env relative to its own installed location, so it works
regardless of which directory the client launches it from.
Development
npm run build # compile
npm run dev # compile on change
npm run smoke # end-to-end test against a live account
npm run inspect # open the MCP Inspector UIsrc/
index.ts tool registration and transport wiring
auth.ts OAuth 2.0 PKCE flow, loopback callback, 0600 token store
api.ts API client: token refresh, pagination, 429/401 handling
analyze.ts aggregation: artist mix, decades, taste diff, listening clock
login.ts one-time authorization CLI
env.ts optional .env loading
tool.ts shared MCP result helpers
scripts/
smoke.mjs end-to-end test over a real stdio client connectionWhat this server cannot do, and why
Spotify has restricted its Web API substantially for apps created recently. These are not bugs here — the data no longer exists at this access tier:
November 2024 — restricted for apps without prior extended access: Audio Features (danceability, energy, tempo, valence), Audio Analysis, Recommendations, Related Artists, Featured Playlists, Category Playlists, 30-second preview URLs.
February 2026 — removed outright:
Removed | Effect |
| No batch artist lookup |
|
|
| Renamed |
Artist | No genre analysis is possible |
Track | No "mainstream vs deep cuts" measure |
Playlist | Track counts come from |
Search | Catalog endpoints cap pages at 10 |
Most Spotify tutorials are built on audio-features and recommendations.
They no longer run. Genre data is gone entirely — genres existed only on
artist objects, and both the batch endpoint and the field itself were removed.
This server uses artist concentration instead: what share of a track set's credits belong to its top few artists. It answers the same underlying question — is this varied or narrow? — from data that still exists.
License
MIT
Available Tools
8 toolsanalyze_playlistAnalyze a playlistA
Full breakdown of one playlist: dominant artists, how concentrated it is, release decades and total runtime. Accepts a playlist name (matched against the user's own playlists) or a Spotify playlist ID.
| Name | Required | Description | Default |
|---|---|---|---|
| playlist | Yes | Playlist name or Spotify playlist ID. | |
| max_tracks | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the disclosure burden. It conveys a read-only analysis operation through the term 'breakdown' and describes the outputs (dominant artists, concentration, release decades, total runtime). It does not clarify behavior for missing playlists, whether arbitrary Spotify IDs are accepted, or whether max_tracks silently limits the analysis, leaving partial transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences, front-loaded with the tool's purpose and output components, followed by input format guidance. Every clause contributes useful information, with no repetition of schema details or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with no output schema, the description covers the main query and gives a sense of the return values. However, the meaning and effect of max_tracks are missing, and the phrase 'Full breakdown' is potentially contradicted by the max_tracks default of 300 if a playlist is larger. This is a notable gap in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%, so the description must compensate for undocumented parameters. It does add meaning to 'playlist' by noting that names are matched against the user's own playlists, but it completely omits max_tracks, which also lacks a description in the schema. The agent cannot infer what max_tracks controls from the description alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('breakdown') and a clear resource ('one playlist'), and enumerates concrete analysis dimensions: dominant artists, concentration, release decades, total runtime. This specificity distinguishes it from sibling tools like my_playlists (which lists playlists) and artist_profile (which focuses on a single artist).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied through the analysis-oriented wording, and input semantics ('playlist name matched against the user's own playlists or a Spotify playlist ID') provide practical context. However, the description does not explicitly state when to choose this tool over alternatives or mention any exclusions, such as preferring search_catalog for finding or my_playlists for listing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
artist_profileArtist profileA
Look up an artist by name and return their catalogue - recent albums and singles - in one call.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Artist name to search for. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries full responsibility for behavioral disclosure. It does state the tool is a lookup that returns 'recent albums and singles' in a single call, implying a read-only operation, but it does not describe response format, ordering, pagination, or whether any auth is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the verb and object, with the qualifier 'in one call' at the end. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple one-parameter schema and no output schema, the description adequately conveys the tool's main purpose and return shape. It could be more specific about what 'recent' means and the structure of returned albums/singles, but the essentials are present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single 'name' parameter is already fully described in the schema ('Artist name to search for'), and the description only restates 'by name' without adding syntax, normalization, or fuzzy-matching details. With 100% schema coverage, the description adds no essential parameter semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('look up') and resource ('artist by name'), and specifies the return content ('catalogue - recent albums and singles'). However, it does not explicitly contrast itself with siblings like search_catalog, so an agent must infer the boundary from context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies usage when a caller needs an artist's discography but provides no explicit when-to-use/when-not-to-use guidance and no references to alternative tools. No exclusions or conditions are stated, leaving the choice to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
my_listening_profileMy listening profileB
Top artists and tracks for a time window in one call - answers 'what am I into lately'.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| time_range | No | short_term = last ~4 weeks, medium_term = last ~6 months, long_term = last ~1 year. | medium_term |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It adds some context ('one call', time window) but does not disclose whether authentication is needed, how results are structured, whether both artists and tracks are returned together, or any pagination/limiting behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the tool's core purpose and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, no annotations, and a minimal description. It omits return format, authentication expectations, parameter semantics for limit, and explicit differentiation from sibling tools. For an agent to invoke it correctly, too much must be inferred.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 50%: time_range has a description but limit does not. The description's phrase 'time window' loosely maps to time_range but adds no detail about limit or how the parameters interact. It does not compensate for the schema's partial coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource ('top artists and tracks') and the scope ('for a time window'), and frames it as answering 'what am I into lately.' It is distinguishable from siblings like recently_played (recent activity vs. top items) and taste_evolution (current profile vs. change over time), though it does not explicitly name them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when the agent needs a user's top artists and tracks over a time window. However, it provides no explicit when-not-to-use guidance and does not mention alternative tools, leaving the agent to infer the boundary against siblings like taste_evolution or recently_played.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
my_playlistsList my playlistsA
Playlists the user owns or follows, with track counts. Use this to find a name to pass to analyze_playlist.
| Name | Required | Description | Default |
|---|---|---|---|
| max | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden, and it does so by scoping results to playlists the user owns or follows and by stating that track counts are included. The "List" verb plus the read-only intent makes side effects clear, though it does not discuss auth or pagination.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tightly packed sentences: the first states the return content and scope, the second gives the downstream use case. No filler, and the purpose is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple optional-parameter list tool with no output schema, the description covers the return values and the intended workflow. It is only slightly incomplete because it does not explicitly say that max caps the result count.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, max, is not mentioned in the description, and there is no parameter description in the schema, so the agent must infer that max limits the number of playlists returned. The schema provides bounds and a default, but the description does not compensate for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The title and description identify a specific list operation: playlists the current user owns or follows, enriched with track counts. It is clearly distinguished from siblings such as analyze_playlist by stating its role as the source of playlist names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states an explicit use case: "Use this to find a name to pass to analyze_playlist." It does not spell out exclusions or alternatives, but sibling tools are mostly distinct domains, so this is sufficient context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
now_playingNow playingA
What the user is listening to right now, if anything.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. The clause 'if anything' usefully discloses that the tool may return no result instead of failing. It does not mention response structure, required user context, or any latency/auth behavior, but for a simple read-only snapshot this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single ten-word sentence with no filler. Every word earns its place: 'right now' establishes recency and 'if anything' sets the null expectation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool, the description covers the core query and the empty case, and the sibling context makes its scope clear. The lack of an output schema means the exact shape of the listening result is not specified, but the simplicity of the tool makes this a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty properties schema, so there is nothing for the description to add. This matches the baseline of 4 for parameterless tools; no parameter semantics are missing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the user's current listening activity with the temporal qualifier 'right now'. It is unambiguous what resource is involved, though it lacks an explicit retrieval verb or a named distinction from siblings like recently_played.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'right now' implies a real-time snapshot, setting it apart from recently_played, but the description never explicitly says when to use this tool versus alternatives or when not to use it. The usage guidance is only implied, not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recently_playedRecently playedB
The most recent plays, with the artists repeated most and which parts of the day the listening clustered in. Spotify caps this at 50 items.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It discloses that results are capped at 50 items and that aggregated patterns are included, but it does not mention auth requirements, pagination, sorting, or what 'recent' means in terms of time window.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single tight sentence with no filler. It front-loads the core purpose and adds the cap as a useful constraint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool, the description is adequate but not complete. It would benefit from explaining the limit parameter, defining the time range of 'recent', and distinguishing the tool from my_listening_profile or taste_evolution. The lack of annotations and output schema leaves these gaps unaddressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description never explains the limit parameter. The phrase 'Spotify caps this at 50 items' hints at a limit but does not tie it to the parameter or clarify how limit affects the response. The schema alone only provides the default/min/max.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the resource (recent plays) and the extras it provides: most-repeated artists and listening time-of-day clustering. It is distinct enough from siblings like now_playing and my_listening_profile, though it does not explicitly differentiate itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no explicit guidance on when to choose this tool over the sibling tools. It is implicitly about recent listening history, but it never names alternatives, exclusions, or conditions that would route an agent here.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_catalogSearch SpotifyA
Search the public catalog for tracks, artists or albums.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | track | |
| limit | No | ||
| query | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does convey that the tool is a public, read-only search rather than a user-specific operation. But it omits potential behavioral details such as result format, whether results are paginated, or any rate-limit considerations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no filler. It communicates the essential purpose immediately and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool, the description is minimally sufficient: it tells the agent the core action and scope. Yet with no annotations and no output schema, an agent would benefit from more guidance about expected result shape or the meaning of the search query and limits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate. It partially mirrors the 'type' enum by naming tracks, artists, and albums, but it does not explain the 'query' parameter or the 'limit' behavior beyond what the raw schema already shows.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Search'), a clear resource ('the public catalog'), and the item types ('tracks, artists or albums'). This distinguishes it from the sibling tools, which focus on user-specific profile and listening data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: whenever the agent needs to find public catalog items. However, it does not explicitly contrast it with alternatives or state when not to use it, leaving the usage boundary to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
taste_evolutionHow my taste is changingA
Compares top artists across all three time windows to show who is rising, fading, and constant. Spotify exposes no listening history, so this diff is the only way to see direction of travel.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It explains the internal mechanism—comparing top artists across three time windows—and the motivating limitation of Spotify's API. It does not state whether the operation is read-only, how many API calls may be involved, or what the output format is, but the conceptual transparency is adequate for a simple analytical tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundancy. The core action and purpose are front-loaded, and the second sentence provides useful context without padding. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter analytical tool with no output schema, the description covers the main purpose and rationale well. However, it leaves the meaning of 'all three time windows' implicit and fails to clarify the return shape or how 'limit' affects results. A bit more detail would make it complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description makes no mention of the single 'limit' parameter. The schema provides type, default, and min/max constraints, but the description does not compensate by explaining what the limit applies to (e.g., number of artists per window). This is a notable gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Compares top artists across all three time windows'. It clearly defines the tool's purpose in terms of rising, fading, and constant artists. The final sentence ('the only way to see direction of travel') differentiates it from sibling tools that likely show static snapshots.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear when-to-use context: when you want to see the direction of taste change. The statement that Spotify exposes no listening history and this diff is the only way establishes the tool's unique role. However, it does not explicitly name sibling alternatives or state when not to use it, stopping short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
v0.1.0- First observed
analyze_playlist - First observed
artist_profile - First observed
my_listening_profile - First observed
my_playlists - First observed
now_playing - First observed
recently_played - First observed
search_catalog - First observed
taste_evolution
TDQS
Tools are mostly distinct, but artist_profile and search_catalog both handle lookups, and my_listening_profile vs taste_evolution both surface top artists. Descriptions clarify the differences well.
All names use snake_case and are readable, but the pattern mixes noun-phrases (my_playlists, now_playing) with verb-phrases (analyze_playlist, search_catalog). Minor inconsistency, no chaos.
8 tools is well-scoped for a personal music insights server. Each tool covers a distinct aspect of the user's listening data and catalog access without redundancy.
The set covers listening profile, taste trends, recent plays, playlists, playlist analysis, artist catalog, search, and current playback. Missing playback control or playlist editing, but those appear outside the server's analytics-focused purpose.
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
The media memory layer for AI agents and their humans. Your AI client gets 29 tools to search your collection, add items, update ratings, preview music, and find patterns across everything you've read, watched, and listened to.
Give any AI assistant real-time access to your phone's GPS and location history.
Query your Twitch streams, events, supporters, raids & rankings from an AI assistant via OAuth.
Spotify: Spotify Data API for Millions of songs & podcasts, artists, albums, playlists and more.
Related MCP Servers
- FlicenseBqualityDmaintenanceEnables AI assistants to control Spotify playback, search for music, manage playlists, and interact with your Spotify library through natural language commands.19-
- AlicenseBqualityDmaintenanceEnables AI assistants to control Spotify playback, manage playlists, search music, and access listening history. Requires Spotify Premium and uses secure OAuth 2.0 with PKCE authentication.1338MIT
- AlicenseAqualityDmaintenanceConnects AI assistants to a self-hosted Your Spotify instance and Spotify's Web API for deep listening analytics and playback control. It enables users to query unlimited listening history, generate custom Wrapped summaries, and manage playlists through natural language.18Apache 2.0
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to control Spotify playback, search music, manage playlists and library, and access user listening insights via the Spotify Web API.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sjtan2302/spotify-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server