# How to integrate Spotify MCP with LangChain

```json
{
  "title": "How to integrate Spotify MCP with LangChain",
  "toolkit": "Spotify",
  "toolkit_slug": "spotify",
  "framework": "LangChain",
  "framework_slug": "langchain",
  "url": "https://composio.dev/toolkits/spotify/framework/langchain",
  "markdown_url": "https://composio.dev/toolkits/spotify/framework/langchain.md",
  "updated_at": "2026-05-12T10:26:55.779Z"
}
```

## Introduction

This guide walks you through connecting Spotify to LangChain using the Composio tool router. By the end, you'll have a working Spotify agent that can add these songs to your running playlist, check if i follow taylor swift, see if your friends follow your playlist through natural language commands.
This guide will help you understand how to give your LangChain agent real control over a Spotify account through Composio's Spotify MCP server.
Before we dive in, let's take a quick look at the key ideas and tools involved.

## Also integrate Spotify with

- [ChatGPT](https://composio.dev/toolkits/spotify/framework/chatgpt)
- [OpenAI Agents SDK](https://composio.dev/toolkits/spotify/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/spotify/framework/claude-agents-sdk)
- [Claude Code](https://composio.dev/toolkits/spotify/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/spotify/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/spotify/framework/codex)
- [Cursor](https://composio.dev/toolkits/spotify/framework/cursor)
- [VS Code](https://composio.dev/toolkits/spotify/framework/vscode)
- [OpenCode](https://composio.dev/toolkits/spotify/framework/opencode)
- [OpenClaw](https://composio.dev/toolkits/spotify/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/spotify/framework/hermes-agent)
- [CLI](https://composio.dev/toolkits/spotify/framework/cli)
- [Google ADK](https://composio.dev/toolkits/spotify/framework/google-adk)
- [Vercel AI SDK](https://composio.dev/toolkits/spotify/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/spotify/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/spotify/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/spotify/framework/crew-ai)

## TL;DR

Here's what you'll learn:
- Get and set up your OpenAI and Composio API keys
- Connect your Spotify project to Composio
- Create a Tool Router MCP session for Spotify
- Initialize an MCP client and retrieve Spotify tools
- Build a LangChain agent that can interact with Spotify
- Set up an interactive chat interface for testing

## What is LangChain?

LangChain is a framework for developing applications powered by language models. It provides tools and abstractions for building agents that can reason, use tools, and maintain conversation context.
Key features include:
- Agent Framework: Build agents that can use tools and make decisions
- MCP Integration: Connect to external services through Model Context Protocol adapters
- Memory Management: Maintain conversation history across interactions
- Multi-Provider Support: Works with OpenAI, Anthropic, and other LLM providers

## What is the Spotify MCP server, and what's possible with it?

The Spotify MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Spotify account. It provides structured and secure access to your playlists, music library, and playback controls, so your agent can perform actions like managing playlists, adding songs to your queue, checking saved tracks, and updating playlist details on your behalf.
- Personalized playlist management: Let your agent add songs or podcasts to playlists, change playlist details like name or privacy settings, and keep your music organized just how you like it.
- Playback control and queue updates: Direct your agent to add tracks or episodes to your current playback queue, helping you line up the perfect listening experience without lifting a finger.
- Library checks and smart recommendations: Have your agent check if specific tracks, albums, shows, or audiobooks are already saved in your Spotify library, so you never add duplicates or miss out on favorites.
- Social and follower insights: Ask your agent to check whether you or others are following certain artists, users, or playlists, making it easy to stay connected to your musical community.
- Podcast and show management: Let your agent verify which podcast episodes or shows are in your library, ensuring you’re always up to date with your latest audio interests.

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `SPOTIFY_ADD_ITEMS_TO_PLAYLIST` | Add items to playlist | Add one or more items to a user's playlist. |
| `SPOTIFY_ADD_ITEM_TO_PLAYBACK_QUEUE` | Add item to playback queue | Add an item to the end of the user's current playback queue. This API only works for users who have Spotify Premium. The order of execution is not guaranteed when you use this API with other Player API endpoints. Required scope: user-modify-playback-state Note: Only tracks and episodes can be added to the queue. Albums and playlists cannot be added directly. |
| `SPOTIFY_CHANGE_PLAYLIST_DETAILS` | Change playlist details | Change a playlist's name and public/private state. The user must own the playlist. This action allows updating the playlist name, description, public/private status, and collaborative mode. At least one of the optional parameters (name, public, collaborative, description) must be provided. Important constraints: - collaborative can only be set to true on non-public playlists (when public is false) - Requires OAuth scope: playlist-modify-public (for public playlists) or playlist-modify-private (for private playlists) - The playlist must be owned by the authenticated user |
| `SPOTIFY_CHECK_IF_USER_FOLLOWS_ARTISTS_OR_USERS` | Check if user follows artists or users | Check to see if the current user is following one or more artists or other Spotify users. |
| `SPOTIFY_CHECK_IF_USERS_FOLLOW_PLAYLIST` | Check if users follow playlist | Check if the current authenticated user is following a specified playlist. This endpoint checks whether the authenticated user follows the given playlist. It returns a boolean value indicating whether the user follows the playlist. Important: Despite the parameter being named 'ids', this endpoint only works for checking if the current authenticated user follows a playlist. You cannot check if arbitrary users follow a playlist. Note: The playlist must be public or the requesting user must own the playlist. |
| `SPOTIFY_CHECK_USER_S_SAVED_ALBUMS` | Check user s saved albums | Check if one or more albums is already saved in the current Spotify user's 'Your Music' library. |
| `SPOTIFY_CHECK_USER_S_SAVED_AUDIOBOOKS` | Check user s saved audiobooks | Check if one or more audiobooks are already saved in the current Spotify user's library. Returns an array of boolean values indicating whether each audiobook (by ID) is saved in the user's library. Requires user-library-read scope. |
| `SPOTIFY_CHECK_USER_S_SAVED_EPISODES` | Check User's Saved Episodes | Check if one or more podcast episodes are saved in the current Spotify user's 'Your Episodes' library. Returns an array of boolean values corresponding to each episode ID provided. **Required OAuth Scope:** user-library-read **Note:** This endpoint is currently in beta and may change without notice. |
| `SPOTIFY_CHECK_USER_S_SAVED_SHOWS` | Check user's saved shows | Check if one or more shows is already saved in the current Spotify user's library. This endpoint checks whether the specified shows are saved in the authenticated user's library. It returns a list of boolean values, one for each show ID provided, indicating whether that show is saved. |
| `SPOTIFY_CHECK_USER_S_SAVED_TRACKS` | Check User's Saved Tracks | Check if one or more tracks is already saved in the current Spotify user's 'Your Music' library. Returns an array of boolean values indicating whether each track is saved (true) or not (false), in the same order as the requested IDs. |
| `SPOTIFY_CREATE_PLAYLIST` | Create playlist | Create a playlist for a Spotify user. (The playlist will be empty until you [add tracks](/documentation/web-api/reference/add-tracks-to-playlist).) Each user is generally limited to a maximum of 11000 playlists. |
| `SPOTIFY_FOLLOW_ARTISTS_OR_USERS` | Follow artists or users | Follow one or more artists or Spotify users on behalf of the current authenticated user. This action adds the specified artists or users to the current user's "Following" list, making their content appear in the user's personalized feed. The operation is idempotent - attempting to follow an already-followed artist/user will succeed without error. Required OAuth scope: user-follow-modify Common use cases: - Follow an artist after liking their music - Follow multiple artists at once (up to 50) - Follow other Spotify users to see their public playlists and activity Note: Artist IDs can be obtained from search results, track objects, or album objects. User IDs can be obtained from user profile endpoints or playlist owner information. |
| `SPOTIFY_FOLLOW_PLAYLIST` | Follow playlist | Add the current user as a follower of a playlist. This action adds the current user as a follower of a specified playlist. The 'public' parameter controls whether the playlist will appear in the user's public profile (visible to others) or remain private (only visible to the user). This operation is idempotent - if the user is already following the playlist, the operation will still succeed without error. Required OAuth scopes: - playlist-modify-public: For following playlists publicly - playlist-modify-private: For following playlists privately Note: Following a playlist does not make you its owner. You can follow any playlist (public, private, or collaborative) if you know its Spotify ID. |
| `SPOTIFY_GET_A_CHAPTER` | Get a chapter | Get Spotify catalog information for a single audiobook chapter including name, description, duration, release date, narrators, and playback information. Audiobook chapters are only available within the US, UK, Canada, Ireland, New Zealand and Australia markets. Use this action to retrieve detailed metadata about a specific chapter when you have its Spotify ID. |
| `SPOTIFY_GET_ALBUM` | Get Album Details | Get Spotify catalog information for a single album. Returns comprehensive album data including metadata, track listing, artist information, cover artwork, popularity score, and availability by market. Use this to fetch details about any album in Spotify's catalog using its unique album ID. |
| `SPOTIFY_GET_ALBUM_TRACKS` | Get album tracks | Get Spotify catalog information about an album's tracks. Optional parameters can be used to limit the number of tracks returned. |
| `SPOTIFY_GET_AN_AUDIOBOOK` | Get an audiobook | Get Spotify catalog information for a single audiobook. Audiobooks are only available within the US, UK, Canada, Ireland, New Zealand and Australia markets. |
| `SPOTIFY_GET_ARTIST` | Get artist | Get detailed Spotify catalog information for a single artist. Returns comprehensive artist data including the artist's name, genres, follower count, profile images, popularity score (0-100), and links to their Spotify profile. Use this action to retrieve metadata about any artist in the Spotify catalog. |
| `SPOTIFY_GET_ARTIST_S_ALBUMS` | Get artist s albums | Get Spotify catalog information about an artist's albums. |
| `SPOTIFY_GET_ARTIST_S_RELATED_ARTISTS` | Get artist s related artists | Get Spotify catalog information about artists similar to a given artist. Similarity is based on analysis of the Spotify community's listening history. |
| `SPOTIFY_GET_ARTIST_S_TOP_TRACKS` | Get Artist's Top Tracks | Get Spotify catalog information about an artist's top tracks by country/market. Returns up to 10 of the artist's most popular tracks in the specified market. Each track includes detailed metadata such as album information, duration, popularity score (0-100), explicit content flag, and preview URLs. Use cases: - Display an artist's most popular songs in a specific region - Build artist profile pages with top tracks - Recommend popular content from an artist to users Note: Track popularity varies by market. The same artist may have different top tracks in different countries based on regional streaming patterns. |
| `SPOTIFY_GET_AUDIOBOOK_CHAPTERS` | Get audiobook chapters | Get Spotify catalog information about an audiobook's chapters. Audiobooks are only available within the US, UK, Canada, Ireland, New Zealand and Australia markets. |
| `SPOTIFY_GET_AVAILABLE_DEVICES` | Get Available Devices | Get information about the user's available Spotify Connect devices. Returns a list of devices that can be used for playback, including their names, types (computer, smartphone, speaker), active status, volume levels, and whether they support API control. Useful for checking available playback targets before transferring playback or controlling volume. Requires the 'user-read-playback-state' scope. Note: Some device models are not supported and will not be listed in the API response. |
| `SPOTIFY_GET_AVAILABLE_MARKETS` | Get available markets | Get the list of markets where Spotify is available. Returns an array of ISO 3166-1 alpha-2 country codes. |
| `SPOTIFY_GET_CURRENTLY_PLAYING_TRACK` | Get currently playing track | Get the object currently being played on the user's Spotify account. |
| `SPOTIFY_GET_CURRENT_USER_S_PLAYLISTS` | Get current user s playlists | Get a list of the playlists owned or followed by the current Spotify user. Returns a paginated list of playlists (both public and private) that the current user owns or follows. Each playlist includes basic metadata such as name, description, owner information, track count, images, and collaborative/public status. Use the limit and offset parameters to paginate through results. The response includes pagination links (next/previous) for easier navigation through large result sets. |
| `SPOTIFY_GET_CURRENT_USER_S_PROFILE` | Get current user s profile | Get detailed profile information about the current authenticated user. This endpoint returns comprehensive user profile data including display name, email address, country, subscription level (premium/free), explicit content settings, profile images, follower count, and Spotify URIs. Required OAuth scopes: - user-read-private: Required to access country, product (subscription level), and explicit content settings - user-read-email: Required to access the user's email address Returns a private user object with all available profile information for the authenticated user. |
| `SPOTIFY_GET_EPISODE` | Get episode | Get Spotify catalog information for a single podcast episode identified by its unique Spotify ID. This endpoint retrieves detailed information about a podcast episode including its name, description, duration, release date, cover art, show information, and playback status. It can also return the user's resume point if the user-read-playback-position scope is authorized. Episodes are podcast content on Spotify. Use this endpoint to get metadata and playback information for a specific episode when you have its Spotify ID. |
| `SPOTIFY_GET_FEATURED_PLAYLISTS` | Get featured playlists | Get a list of Spotify's editorially curated featured playlists. These are the playlists shown on a Spotify player's 'Browse' tab and are updated regularly by Spotify's editorial team. The response includes a localized message and a paginated list of simplified playlist objects. |
| `SPOTIFY_GET_FOLLOWED_ARTISTS` | Get followed artists | Get all artists followed by the current user. Returns a cursor-paginated list of artist objects with full details including name, genres, popularity, images, and follower counts. Use the 'after' parameter to navigate through pages of results. Requires the 'user-follow-read' authorization scope. |
| `SPOTIFY_GET_NEW_RELEASES` | Get new releases | Get a list of new album releases featured in Spotify (shown, for example, on a Spotify player's "Browse" tab). |
| `SPOTIFY_GET_PLAYBACK_STATE` | Get playback state | Get information about the user's current playback state, including track or episode, progress, and active device. Returns detailed playback information when content is actively playing, including the current track/episode, playback progress, device details, repeat/shuffle state, and playback context. Returns HTTP 204 (No Content) when nothing is currently playing. Requires OAuth scope: user-read-playback-state |
| `SPOTIFY_GET_PLAYLIST` | Get playlist | Get a playlist owned by a Spotify user. This endpoint retrieves detailed information about a specific Spotify playlist, including its metadata (name, description, public/collaborative status), owner information, cover images, and the tracks/episodes it contains. The response includes a paginated tracks object with full details about each item in the playlist. Required OAuth scope: playlist-read-private (for private playlists) or playlist-read-collaborative (for collaborative playlists). Public playlists can be accessed without special scopes. |
| `SPOTIFY_GET_PLAYLIST_COVER_IMAGE` | Get playlist cover image | Get the current image(s) associated with a specific playlist. Returns an array of image objects containing the URL, height, and width of each cover image. The array may be empty if the playlist has no cover image, or contain up to three images returned by size in descending order. Note: The source URL for the image is temporary and will expire in less than a day. |
| `SPOTIFY_GET_PLAYLIST_ITEMS` | Get playlist items | Get full details of the items of a playlist owned by a Spotify user. This endpoint retrieves the tracks and/or episodes in a playlist. It supports pagination and allows filtering the response fields for optimization. |
| `SPOTIFY_GET_RECENTLY_PLAYED_TRACKS` | Get recently played tracks | Get tracks from the current user's recently played tracks. _**Note**: Currently doesn't support podcast episodes._ |
| `SPOTIFY_GET_RECOMMENDATIONS` | Get recommendations | Get track recommendations based on seed artists, genres, and/or tracks. At least one seed is required (up to 5 total). Optionally tune recommendations with audio feature parameters (acousticness, danceability, energy, etc.). IMPORTANT: This endpoint requires Spotify Extended API Access (restricted since Nov 27, 2024). Accounts without extended access will receive a 404 error. See: https://developer.spotify.com/blog/2024-11-27-changes-to-the-web-api Returns a list of recommended tracks with full track metadata including artists, album info, and audio features. |
| `SPOTIFY_GET_SEVERAL_ALBUMS` | Get several albums | Get Spotify catalog information for multiple albums identified by their Spotify IDs. Returns detailed album data including name, artists, tracks, release date, images, and more. Maximum 20 album IDs per request. |
| `SPOTIFY_GET_SEVERAL_ARTISTS` | Get several artists | Get Spotify catalog information for several artists based on their Spotify IDs. |
| `SPOTIFY_GET_SEVERAL_AUDIOBOOKS` | Get several audiobooks | Retrieve Spotify catalog information for multiple audiobooks in a single request. This action fetches detailed metadata for up to 50 audiobooks at once using their Spotify IDs. Each audiobook object includes: - Title, description, and edition information - Authors and narrators - Chapter information and count - Cover images in multiple sizes - Language and market availability - Publisher and copyright details Audiobooks that don't exist or are unavailable in the requested market will appear as null in the response array (not omitted). **Important**: Audiobooks are only available in US, UK, Canada, Ireland, New Zealand, and Australia markets. Specify the market parameter to ensure content availability for your target region. **Use Cases**: - Bulk retrieval of audiobook metadata - Validating audiobook availability across markets - Building audiobook catalogs or collections - Displaying audiobook details in applications |
| `SPOTIFY_GET_SEVERAL_BROWSE_CATEGORIES` | Get several browse categories | Get a list of categories used to tag items in Spotify (on, for example, the Spotify player's "Browse" tab). |
| `SPOTIFY_GET_SEVERAL_CHAPTERS` | Get several chapters | Get Spotify catalog information for several audiobook chapters identified by their Spotify IDs. This endpoint allows you to fetch detailed information about up to 50 chapters at once, including chapter metadata, duration, descriptions, images, and parent audiobook information. Chapters are only available within the US, UK, Canada, Ireland, New Zealand and Australia markets. |
| `SPOTIFY_GET_SEVERAL_EPISODES` | Get several episodes | Get Spotify catalog information for several episodes based on their Spotify IDs. |
| `SPOTIFY_GET_SEVERAL_SHOWS` | Get several shows | Get Spotify catalog information for several shows (podcasts) based on their Spotify IDs. This endpoint allows you to retrieve detailed information about multiple shows in a single request, with a maximum of 50 show IDs per request. |
| `SPOTIFY_GET_SEVERAL_TRACKS` | Get several tracks | Get Spotify catalog information for multiple tracks based on their Spotify IDs. |
| `SPOTIFY_GET_SHOW` | Get show | Get Spotify catalog information for a single show (podcast) identified by its unique Spotify ID. |
| `SPOTIFY_GET_SHOW_EPISODES` | Get show episodes | Get Spotify catalog information about a show's episodes. Optional parameters can be used to limit the number of episodes returned. This endpoint retrieves a paginated list of episodes for a specific podcast/show. |
| `SPOTIFY_GET_SINGLE_BROWSE_CATEGORY` | Get single browse category | Get a single category used to tag items in Spotify (on, for example, the Spotify player's "Browse" tab). Returns detailed information about the category including its name, icons, and unique identifier. |
| `SPOTIFY_GET_THE_USER_S_QUEUE` | Get the user's queue | Get the list of tracks and episodes in the user's playback queue. Returns the currently playing track/episode and the queue of upcoming items. This is a read-only operation that does not modify the queue. Requirements: - Spotify Premium subscription required - Requires one of these OAuth scopes: - user-read-currently-playing - user-read-playback-state - An active Spotify session (user must be logged in on a device) Returns: - currently_playing: The track or episode currently playing (may be null) - queue: List of tracks/episodes queued for playback (may be empty) Common errors: - 403 Forbidden: Premium subscription required or insufficient OAuth scopes - 204 No Content: No active playback session |
| `SPOTIFY_GET_TRACK` | Get track | Get Spotify catalog information for a single track identified by its unique Spotify ID. |
| `SPOTIFY_GET_TRACK_S_AUDIO_ANALYSIS` | Get Track's Audio Analysis | Get a comprehensive audio analysis for a Spotify track. Returns detailed structural and musical characteristics including: - Meta information (analyzer version, timestamp, processing time) - Track properties (tempo, key, mode, time signature, loudness, duration) - Temporal structure (bars, beats, sections, tatums) - Segments with pitch content and timbre characteristics All timing values are in seconds. Confidence scores range from 0.0 to 1.0. Useful for music analysis, visualization, and recommendation systems. |
| `SPOTIFY_GET_USER_S_PLAYLISTS` | Get user's playlists | Get a paginated list of playlists owned or followed by a Spotify user. This endpoint retrieves all public playlists for any user. To access private and collaborative playlists, you must have the appropriate OAuth scopes and the user must have authorized your application. Required OAuth scopes for private/collaborative playlists: - playlist-read-private: Required to access user's private playlists - playlist-read-collaborative: Required to access collaborative playlists The response includes playlist metadata such as name, description, owner info, images, track count, and collaboration status. Use the limit and offset parameters to paginate through large playlist collections. Common use cases: - Display a user's public playlist library - Build playlist discovery features - Analyze user's music organization patterns - Enable playlist selection interfaces |
| `SPOTIFY_GET_USER_S_PROFILE` | Get user's profile | Get public profile information about a Spotify user. This endpoint retrieves publicly available information for any Spotify user, including their display name, profile images, follower count, and Spotify URIs. Unlike the 'Get Current User's Profile' endpoint, this only returns public data and does not require specific OAuth scopes. Returns a public user object with the user's ID, display name (if available), external URLs, follower count, profile images, and Spotify URI. |
| `SPOTIFY_GET_USER_S_SAVED_ALBUMS` | Get user s saved albums | Get a list of albums saved in the current Spotify user's library ('Your Music'). Returns a paginated list of albums that the user has saved to their library, including when each album was added and full album details (tracks, artists, images, etc.). Supports pagination via limit and offset parameters, and can filter by market availability. Required OAuth scope: user-library-read |
| `SPOTIFY_GET_USER_S_SAVED_AUDIOBOOKS` | Get user s saved audiobooks | Get a list of the audiobooks saved in the current Spotify user's 'Your Music' library. |
| `SPOTIFY_GET_USER_S_SAVED_EPISODES` | Get user's saved episodes | Get a list of episodes saved in the current Spotify user's library. This endpoint retrieves a paginated list of podcast episodes that the authenticated user has saved to their Spotify library. Each item in the response includes the full episode details and the timestamp when it was added to the library. **Required OAuth Scopes:** - user-library-read: Access your saved content - user-read-playback-position: Read your position in content you have played (for resume_point) **Note:** This endpoint is currently in beta and may change without warning. Please share feedback or issues in the Spotify developer community forum. |
| `SPOTIFY_GET_USER_S_SAVED_SHOWS` | Get User's Saved Shows | Get a list of shows saved in the current Spotify user's library. Optional parameters can be used to limit the number of shows returned. |
| `SPOTIFY_GET_USER_S_SAVED_TRACKS` | Get User's Saved Tracks | Get a list of the songs saved in the current Spotify user's 'Your Music' library. Returns paginated results with track details including album info, artists, duration, and when each track was saved. |
| `SPOTIFY_GET_USER_S_TOP_ARTISTS` | Get User's Top Artists | Get the current user's top artists based on calculated affinity. This endpoint retrieves the current user's top artists based on their listening history and calculated affinity. The affinity is computed over a specified time frame (short_term, medium_term, or long_term). Required OAuth Scope: user-top-read Returns a paginated list of artist objects including their name, popularity, genres, images, and follower counts. Useful for understanding user preferences and music taste. |
| `SPOTIFY_GET_USER_S_TOP_TRACKS` | Get User's Top Tracks | Get the current user's top tracks based on calculated affinity. Returns the user's most-played tracks over different time periods based on their listening history and calculated affinity. Required OAuth Scope: user-top-read Note: The Spotify API limits results to the top 50 tracks per time range. Returns detailed track information including artist names, album details, popularity scores, duration, and preview URLs. Useful for understanding user listening preferences and music taste. |
| `SPOTIFY_PAUSE_PLAYBACK` | Pause playback | Pause playback on the user's account. Pauses playback on the currently active device or on a specified device. Returns immediately with success when playback is paused. If no device is specified, the currently active device will be paused. Requirements: - Spotify Premium subscription - OAuth scope: user-modify-playback-state - Active playback session Note: The order of execution is not guaranteed when you use this API with other Player API endpoints. If playback is already paused, this action will still succeed (idempotent). Common scenarios: - Pause current playback: Call with no parameters - Pause specific device: Provide device_id parameter Error scenarios: - 403: User does not have Spotify Premium - 404: No active device found |
| `SPOTIFY_REMOVE_PLAYLIST_ITEMS` | Remove playlist items | Remove one or more items from a user's playlist. This endpoint removes tracks or episodes from a playlist. You can remove items by URI (removes all occurrences) or by URI + positions (removes specific occurrences). Requires 'playlist-modify-public' scope for public playlists or 'playlist-modify-private' scope for private playlists. |
| `SPOTIFY_REMOVE_USERS_SAVED_ALBUMS` | Remove users saved albums | Remove one or more albums from the current user's 'Your Music' library. This action removes albums from the user's saved albums collection in 'Your Library'. The operation is idempotent - removing an album that isn't saved will not cause an error. Required OAuth scope: user-library-modify |
| `SPOTIFY_REMOVE_USER_S_SAVED_AUDIOBOOKS` | Remove User's Saved Audiobooks | Remove one or more audiobooks from the current user's Spotify library. This endpoint removes saved audiobooks from the user's library. Audiobook IDs can be specified as a comma-separated string or as a list of IDs. Maximum of 50 IDs per request. Note: Audiobooks are only available in the US, UK, Canada, Ireland, New Zealand, and Australia markets. Required scope: user-library-modify |
| `SPOTIFY_REMOVE_USER_S_SAVED_EPISODES` | Remove user's saved episodes | Remove one or more episodes from the current user's library. This endpoint removes episodes that have been saved to the user's "Your Episodes" library. The operation is idempotent - removing an episode that is not saved will return success. Up to 50 episode IDs can be removed in a single request. Required scope: user-library-modify Note: This API endpoint is in beta and may change without notice. |
| `SPOTIFY_REMOVE_USER_S_SAVED_SHOWS` | Remove user s saved shows | Delete one or more shows from current Spotify user's library. |
| `SPOTIFY_REMOVE_USER_S_SAVED_TRACKS` | Remove user s saved tracks | Remove one or more tracks from the current user's 'Your Music' library. |
| `SPOTIFY_SAVE_ALBUMS_FOR_CURRENT_USER` | Save albums for current user | Save one or more albums to the current user's 'Your Music' library. This action adds albums to the user's saved albums collection, which can be accessed later through 'Your Library'. The operation is idempotent - saving an album that is already saved will not cause an error. Required OAuth scope: user-library-modify |
| `SPOTIFY_SAVE_AUDIOBOOKS_FOR_CURRENT_USER` | Save audiobooks for current user | Save one or more audiobooks to the current user's library. This action adds audiobooks to the user's saved audiobooks collection, which can be accessed later through 'Your Library'. The operation is idempotent - saving an audiobook that is already saved will not cause an error. Required OAuth scope: user-library-modify |
| `SPOTIFY_SAVE_EPISODES_FOR_CURRENT_USER` | Save episodes for current user | Save one or more podcast episodes to the current user's library. This endpoint saves episodes to the user's "Your Episodes" library, making them easily accessible for later playback. The operation is idempotent - saving an episode that is already saved will return success. Up to 50 episode IDs can be saved in a single request. Required scope: user-library-modify Note: This API endpoint is in beta and may change without notice. |
| `SPOTIFY_SAVE_SHOWS_FOR_CURRENT_USER` | Save shows for current user | Save one or more shows to current Spotify user's library. Requires the user-library-modify scope. Maximum of 50 show IDs per request. |
| `SPOTIFY_SAVE_TRACKS_FOR_CURRENT_USER` | Save tracks for current user | Save one or more tracks to the current user's 'Your Music' library. This action adds tracks to the user's saved tracks collection. You can provide either: - A simple list of track IDs (up to 50) - A list of timestamped IDs to preserve chronological order Requires the 'user-library-modify' OAuth scope. |
| `SPOTIFY_SEARCH_FOR_ITEM` | Search for item | Get Spotify catalog information about albums, artists, playlists, tracks, shows, episodes or audiobooks that match a keyword string. Audiobooks are only available within the US, UK, Canada, Ireland, New Zealand and Australia markets. |
| `SPOTIFY_SEEK_TO_POSITION` | Seek to position | Seek to a specific position in the user's currently playing track. This action allows you to skip to any point in the currently playing track by specifying a position in milliseconds. For example, to skip to 1 minute into the track, use position_ms=60000. **Requirements:** - Spotify Premium subscription required - User must have an active playback session with a track playing - Required OAuth scope: user-modify-playback-state **Behavior:** - Returns HTTP 204 No Content on success (no response body) - If position_ms exceeds track duration, playback skips to the next track - If no device_id is specified, targets the currently active device - Execution order is not guaranteed when used with other Player API endpoints **Common Use Cases:** - Skip to a specific timestamp in a podcast or long track - Resume playback from where a user left off - Implement custom seek controls in your application |
| `SPOTIFY_SET_PLAYBACK_VOLUME` | Set playback volume | Set the volume for the user's current playback device. This API only works for users who have Spotify Premium. The order of execution is not guaranteed when you use this API with other Player API endpoints. |
| `SPOTIFY_SET_REPEAT_MODE` | Set repeat mode | Set the repeat mode for the user's playback. Controls whether playback should repeat the current track, the current context (playlist, album, etc.), or not repeat at all. The change takes effect immediately on the user's active device. Requirements: - Spotify Premium subscription - OAuth scope: user-modify-playback-state - Active playback session Valid repeat modes: - "track": Repeat the current track continuously - "context": Repeat the current context (playlist/album/etc.) - "off": Turn repeat off Note: The order of execution is not guaranteed when you use this API with other Player API endpoints. This action is idempotent - setting the same repeat mode multiple times has the same effect as setting it once. Common scenarios: - Turn off repeat: {"state": "off"} - Repeat current track: {"state": "track"} - Repeat playlist/album: {"state": "context"} - Target specific device: {"state": "off", "device_id": "abc123"} Error scenarios: - 403: User does not have Spotify Premium - 404: No active device found |
| `SPOTIFY_SKIP_TO_NEXT` | Skip to next | Skips to next track in the user's queue. This API only works for users who have Spotify Premium. The order of execution is not guaranteed when you use this API with other Player API endpoints. |
| `SPOTIFY_SKIP_TO_PREVIOUS` | Skip to previous | Skips to the previous track in the user's queue. Requirements: - Spotify Premium subscription - Active playback (user must be currently playing music) - Requires 'user-modify-playback-state' scope Note: The order of execution is not guaranteed when you use this API with other Player API endpoints. |
| `SPOTIFY_START_RESUME_PLAYBACK` | Start resume playback | Start a new context or resume current playback on the user's active device. Starts playback of a specific context (album, artist, or playlist), a list of tracks, or resumes currently paused playback. Returns immediately with success when playback starts. Requirements: - Spotify Premium subscription - OAuth scope: user-modify-playback-state - At least one active Spotify device (mobile, desktop, web player, or smart speaker) Usage patterns: - Resume paused playback: Call with no parameters - Play an album/playlist: Use 'context_uri' parameter - Play specific tracks: Use 'uris' parameter - Play from a specific track in a context: Use 'context_uri' with 'offset' - Start from a specific position in a track: Use 'position_ms' Note: The order of execution is not guaranteed when you use this API with other Player API endpoints. You cannot use both 'context_uri' and 'uris' parameters together. Common error scenarios: - 403: User does not have Spotify Premium - 404: No active device found |
| `SPOTIFY_TOGGLE_PLAYBACK_SHUFFLE` | Toggle playback shuffle | Toggle shuffle on or off for user's playback. This API only works for users who have Spotify Premium. The order of execution is not guaranteed when you use this API with other Player API endpoints. Required OAuth scope: user-modify-playback-state Note: This endpoint returns 204 No Content on success, 404 if no active device is found, and 403 if the user does not have an active Spotify Premium subscription. |
| `SPOTIFY_TRANSFER_PLAYBACK` | Transfer playback | Transfer playback to a new device and optionally begin playback. Requirements: - Spotify Premium subscription is required - Target device must be active and available (use Get Available Devices to retrieve device IDs) - Requires user-modify-playback-state scope Note: The order of execution is not guaranteed when you use this API with other Player API endpoints. Returns 204 No Content on success, 403 Forbidden if user doesn't have Premium. |
| `SPOTIFY_UNFOLLOW_ARTISTS_OR_USERS` | Unfollow artists or users | Remove the current user as a follower of one or more artists or other Spotify users. This action removes the specified artists or users from the current user's "Following" list, stopping their content from appearing in the user's personalized feed. The operation is idempotent - attempting to unfollow an already-unfollowed artist/user will succeed without error. Required OAuth scope: user-follow-modify Common use cases: - Unfollow an artist you no longer want to track - Unfollow multiple artists at once (up to 50) - Unfollow other Spotify users to stop seeing their public playlists and activity - Clean up your following list by removing inactive or irrelevant accounts Note: Artist IDs can be obtained from search results, track objects, or album objects. User IDs can be obtained from user profile endpoints or playlist owner information. |
| `SPOTIFY_UNFOLLOW_PLAYLIST` | Unfollow playlist | Remove the current user as a follower of a playlist. This action removes the current user from following a playlist. The user no longer receives updates from the playlist and it is removed from their followed playlists list. This operation is idempotent - if the user is not currently following the playlist, the operation will still succeed. Required OAuth scopes: - playlist-modify-public: For unfollowing public playlists - playlist-modify-private: For unfollowing private playlists Note: Even if you are the playlist's owner, unfollowing removes it from your library. There is no separate "delete" endpoint - unfollowing is the equivalent operation. |
| `SPOTIFY_UPDATE_PLAYLIST_ITEMS` | Update playlist items | Either replace all tracks in a playlist OR reorder existing tracks within it. **REPLACE mode**: Use `uris` parameter to completely overwrite all tracks in the playlist. Example: Replace all tracks with 3 specific tracks. **REORDER mode**: Use `range_start`, `insert_before`, and optionally `range_length`/`snapshot_id` to move tracks within the playlist without adding/removing any. Example: Move tracks at positions 5-7 to the beginning of the playlist. These two modes are mutually exclusive - you cannot use both in the same request. |

## Supported Triggers

| Trigger slug | Name | Description |
|---|---|---|
| `SPOTIFY_NEW_DEVICE_TRIGGER` | New Device Added | Triggers when a new device is added. |
| `SPOTIFY_PLAYLIST_ITEM_TRIGGER` | Spotify Playlist Item Change | Triggers when songs are added to or removed from a Spotify playlist. |
| `SPOTIFY_PLAYLIST_TRIGGER` | New Playlist Created or Deleted | Triggers when a new playlist is created or deleted. |

## Creating MCP Server - Stand-alone vs Composio SDK

The Spotify MCP server is an implementation of the Model Context Protocol that connects your AI agent to Spotify. It provides structured and secure access so your agent can perform Spotify operations on your behalf through a secure, permission-based interface.
With Composio's managed implementation, you don't have to create your own developer app. For production, if you're building an end product, we recommend using your own credentials. The managed server helps you prototype fast and go from 0-1 faster.

## Step-by-step Guide

### 1. Prerequisites

No description provided.

### 1. Getting API Keys for OpenAI and Composio

OpenAI API Key
- Go to the [OpenAI dashboard](https://platform.openai.com/settings/organization/api-keys) and create an API key. You'll need credits to use the models, or you can connect to another model provider.
- Keep the API key safe.
Composio API Key
- Log in to the [Composio dashboard](https://dashboard.composio.dev?utm_source=toolkits&utm_medium=framework_docs).
- Navigate to your API settings and generate a new API key.
- Store this key securely as you'll need it for authentication.

### 2. Install dependencies

No description provided.
```python
pip install composio-langchain langchain-mcp-adapters langchain python-dotenv
```

```typescript
npm install @composio/langchain @langchain/core @langchain/openai @langchain/mcp-adapters dotenv
```

### 3. Set up environment variables

Create a .env file in your project root.
What's happening:
- COMPOSIO_API_KEY authenticates your requests to Composio's API
- COMPOSIO_USER_ID identifies the user for session management
- OPENAI_API_KEY enables access to OpenAI's language models
```bash
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_composio_user_id_here
OPENAI_API_KEY=your_openai_api_key_here
```

### 4. Import dependencies

No description provided.
```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from dotenv import load_dotenv
from composio import Composio
import asyncio
import os

load_dotenv()
```

```typescript
import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createAgent } from "langchain";
import * as readline from 'readline';
import 'dotenv/config';

dotenv.config();
```

### 5. Initialize Composio client

What's happening:
- We're loading the COMPOSIO_API_KEY from environment variables and validating it exists
- Creating a Composio instance that will manage our connection to Spotify tools
- Validating that COMPOSIO_USER_ID is also set before proceeding
```python
async def main():
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))

    if not os.getenv("COMPOSIO_API_KEY"):
        raise ValueError("COMPOSIO_API_KEY is not set")
    if not os.getenv("COMPOSIO_USER_ID"):
        raise ValueError("COMPOSIO_USER_ID is not set")
```

```typescript
const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.COMPOSIO_USER_ID;

if (!composioApiKey) throw new Error('COMPOSIO_API_KEY is not set');
if (!userId) throw new Error('COMPOSIO_USER_ID is not set');

async function main() {
    const composio = new Composio({
        apiKey: composioApiKey as string,
        provider: new LangchainProvider()
    });
```

### 6. Create a Tool Router session

What's happening:
- We're creating a Tool Router session that gives your agent access to Spotify tools
- The create method takes the user ID and specifies which toolkits should be available
- The returned session.mcp.url is the MCP server URL that your agent will use
- This approach allows the agent to dynamically load and use Spotify tools as needed
```python
# Create Tool Router session for Spotify
session = composio.create(
    user_id=os.getenv("COMPOSIO_USER_ID"),
    toolkits=['spotify']
)

url = session.mcp.url
```

```typescript
const session = await composio.create(
    userId as string,
    {
        toolkits: ['spotify']
    }
);

const url = session.mcp.url;
```

### 7. Configure the agent with the MCP URL

No description provided.
```python
client = MultiServerMCPClient({
    "spotify-agent": {
        "transport": "streamable_http",
        "url": session.mcp.url,
        "headers": {
            "x-api-key": os.getenv("COMPOSIO_API_KEY")
        }
    }
})

tools = await client.get_tools()

agent = create_agent("gpt-5", tools)
```

```typescript
const client = new MultiServerMCPClient({
    "spotify-agent": {
        transport: "http",
        url: url,
        headers: {
            "x-api-key": process.env.COMPOSIO_API_KEY
        }
    }
});

const tools = await client.getTools();

const agent = createAgent({ model: "gpt-5", tools });
```

### 8. Set up interactive chat interface

No description provided.
```python
conversation_history = []

print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Spotify related question or task to the agent.\n")

while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ['exit', 'quit', 'bye']:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    conversation_history.append({"role": "user", "content": user_input})
    print("\nAgent is thinking...\n")

    response = await agent.ainvoke({"messages": conversation_history})
    conversation_history = response['messages']
    final_response = response['messages'][-1].content
    print(f"Agent: {final_response}\n")
```

```typescript
let conversationHistory: any[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log("Ask any Spotify related question or task to the agent.\n");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
});

rl.prompt();

rl.on('line', async (userInput: string) => {
    const trimmedInput = userInput.trim();

    if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
        console.log("\nGoodbye!");
        rl.close();
        process.exit(0);
    }

    if (!trimmedInput) {
        rl.prompt();
        return;
    }

    conversationHistory.push({ role: "user", content: trimmedInput });
    console.log("\nAgent is thinking...\n");

    const response = await agent.invoke({ messages: conversationHistory });
    conversationHistory = response.messages;

    const finalResponse = response.messages[response.messages.length - 1]?.content;
    console.log(`Agent: ${finalResponse}\n`);
        
        rl.prompt();
    });

    rl.on('close', () => {
        console.log('\n👋 Session ended.');
        process.exit(0);
    });
```

### 9. Run the application

No description provided.
```python
if __name__ == "__main__":
    asyncio.run(main())
```

```typescript
main().catch((err) => {
    console.error('Fatal error:', err);
    process.exit(1);
});
```

## Complete Code

```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from dotenv import load_dotenv
from composio import Composio
import asyncio
import os

load_dotenv()

async def main():
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    
    if not os.getenv("COMPOSIO_API_KEY"):
        raise ValueError("COMPOSIO_API_KEY is not set")
    if not os.getenv("COMPOSIO_USER_ID"):
        raise ValueError("COMPOSIO_USER_ID is not set")
    
    session = composio.create(
        user_id=os.getenv("COMPOSIO_USER_ID"),
        toolkits=['spotify']
    )

    url = session.mcp.url
    
    client = MultiServerMCPClient({
        "spotify-agent": {
            "transport": "streamable_http",
            "url": url,
            "headers": {
                "x-api-key": os.getenv("COMPOSIO_API_KEY")
            }
        }
    })
    
    tools = await client.get_tools()
  
    agent = create_agent("gpt-5", tools)
    
    conversation_history = []
    
    print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
    print("Ask any Spotify related question or task to the agent.\n")
    
    while True:
        user_input = input("You: ").strip()
        
        if user_input.lower() in ['exit', 'quit', 'bye']:
            print("\nGoodbye!")
            break
        
        if not user_input:
            continue
        
        conversation_history.append({"role": "user", "content": user_input})
        print("\nAgent is thinking...\n")
        
        response = await agent.ainvoke({"messages": conversation_history})
        conversation_history = response['messages']
        final_response = response['messages'][-1].content
        print(f"Agent: {final_response}\n")

if __name__ == "__main__":
    asyncio.run(main())
```

```typescript
import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";  
import { createAgent } from "langchain";
import * as readline from 'readline';
import 'dotenv/config';

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.COMPOSIO_USER_ID;

if (!composioApiKey) throw new Error('COMPOSIO_API_KEY is not set');
if (!userId) throw new Error('COMPOSIO_USER_ID is not set');

async function main() {
    const composio = new Composio({
        apiKey: composioApiKey as string,
        provider: new LangchainProvider()
    });

    const session = await composio.create(
        userId as string,
        {
            toolkits: ['spotify']
        }
    );

    const url = session.mcp.url;
    
    const client = new MultiServerMCPClient({
        "spotify-agent": {
            transport: "http",
            url: url,
            headers: {
                "x-api-key": process.env.COMPOSIO_API_KEY
            }
        }
    });
    
    const tools = await client.getTools();
  
    const agent = createAgent({ model: "gpt-5", tools });
    
    let conversationHistory: any[] = [];
    
    console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
    console.log("Ask any Spotify related question or task to the agent.\n");
    
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
        prompt: 'You: '
    });

    rl.prompt();

    rl.on('line', async (userInput: string) => {
        const trimmedInput = userInput.trim();
        
        if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
            console.log("\nGoodbye!");
            rl.close();
            process.exit(0);
        }
        
        if (!trimmedInput) {
            rl.prompt();
            return;
        }
        
        conversationHistory.push({ role: "user", content: trimmedInput });
        console.log("\nAgent is thinking...\n");
        
        const response = await agent.invoke({ messages: conversationHistory });
        conversationHistory = response.messages;
        
        const finalResponse = response.messages[response.messages.length - 1]?.content;
        console.log(`Agent: ${finalResponse}\n`);
        
        rl.prompt();
    });

    rl.on('close', () => {
        console.log('\nSession ended.');
        process.exit(0);
    });
}

main().catch((err) => {
    console.error('Fatal error:', err);
    process.exit(1);
});
```

## Conclusion

You've successfully built a LangChain agent that can interact with Spotify through Composio's Tool Router.
Key features of this implementation:
- Dynamic tool loading through Composio's Tool Router
- Conversation history maintenance for context-aware responses
- Async Python provides clean, efficient execution of agent workflows
You can extend this further by adding error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows.

## How to build Spotify MCP Agent with another framework

- [ChatGPT](https://composio.dev/toolkits/spotify/framework/chatgpt)
- [OpenAI Agents SDK](https://composio.dev/toolkits/spotify/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/spotify/framework/claude-agents-sdk)
- [Claude Code](https://composio.dev/toolkits/spotify/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/spotify/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/spotify/framework/codex)
- [Cursor](https://composio.dev/toolkits/spotify/framework/cursor)
- [VS Code](https://composio.dev/toolkits/spotify/framework/vscode)
- [OpenCode](https://composio.dev/toolkits/spotify/framework/opencode)
- [OpenClaw](https://composio.dev/toolkits/spotify/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/spotify/framework/hermes-agent)
- [CLI](https://composio.dev/toolkits/spotify/framework/cli)
- [Google ADK](https://composio.dev/toolkits/spotify/framework/google-adk)
- [Vercel AI SDK](https://composio.dev/toolkits/spotify/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/spotify/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/spotify/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/spotify/framework/crew-ai)

## Related Toolkits

- [Youtube](https://composio.dev/toolkits/youtube) - YouTube is a leading video-sharing platform for uploading, streaming, and discovering content. It empowers creators and businesses to reach global audiences and monetize their work.
- [Amara](https://composio.dev/toolkits/amara) - Amara is a collaborative platform for creating and managing subtitles and captions for videos. It helps make content accessible and multilingual for global audiences.
- [Cats](https://composio.dev/toolkits/cats) - Cats is an API with a huge library of cat images, breed data, and cat facts. It makes finding adorable cat photos and trivia effortless for your apps and users.
- [Chatfai](https://composio.dev/toolkits/chatfai) - Chatfai is an AI platform that lets users talk to AI versions of fictional characters from books, movies, and games. It offers an engaging, interactive experience for fans to chat, roleplay, and explore creative dialogues.
- [Cincopa](https://composio.dev/toolkits/cincopa) - Cincopa is a multimedia platform for uploading, managing, and customizing videos, images, and audio. It helps you deliver engaging media experiences with robust APIs and flexible integrations.
- [Dungeon fighter online](https://composio.dev/toolkits/dungeon_fighter_online) - Dungeon Fighter Online (DFO) is an arcade-style, side-scrolling action RPG packed with dynamic combat and progression. Play solo or with friends to battle monsters, complete quests, and upgrade your characters.
- [Elevenlabs](https://composio.dev/toolkits/elevenlabs) - Elevenlabs is an advanced AI voice generation platform for lifelike, multilingual speech synthesis. Perfect for creating natural voices for videos, apps, and business content in seconds.
- [Elevenreader](https://composio.dev/toolkits/elevenreader) - Elevenreader is an AI-powered text-to-speech service by ElevenLabs that converts written content into lifelike audio. It enables fast, natural audio generation from any text.
- [Epic games](https://composio.dev/toolkits/epic_games) - Epic Games is a leading video game publisher and digital storefront, known for Fortnite and Unreal Engine. It lets gamers access, manage, and purchase games all in one place.
- [Fal.ai](https://composio.dev/toolkits/fal_ai) - Fal.ai is a generative media platform offering 600+ AI models for images, video, voice, and audio. Developers use Fal.ai for fast, scalable access to cutting-edge generative AI tools.
- [Giphy](https://composio.dev/toolkits/giphy) - Giphy is the largest online library for searching and sharing GIFs and stickers. Instantly add vibrant animated content to your apps, chats, and workflows.
- [Headout](https://composio.dev/toolkits/headout) - Headout is a global platform for booking travel experiences, tours, and entertainment. It helps users discover and secure activities at top destinations, all in one place.
- [Imagekit io](https://composio.dev/toolkits/imagekit_io) - ImageKit.io is a cloud-based media management platform for image and video delivery. Instantly optimize, transform, and deliver visuals globally via a lightning-fast CDN.
- [Listennotes](https://composio.dev/toolkits/listennotes) - Listennotes is a powerful podcast search engine with a massive global database. Discover, search, and curate podcasts from around the world in seconds.
- [News api](https://composio.dev/toolkits/news_api) - News api is a REST API for searching and retrieving live news articles from across the web. Instantly access headlines, coverage, and breaking stories from thousands of sources.
- [RAWG Video Games Database](https://composio.dev/toolkits/rawg_video_games_database) - RAWG Video Games Database is the largest video game discovery and info service. Instantly access comprehensive details, ratings, and release dates for thousands of games.
- [Seat geek](https://composio.dev/toolkits/seat_geek) - SeatGeek is a live event platform offering APIs for concerts, sports, and theater data. Instantly access events, venues, and performers info for smarter ticketing and discovery.
- [Shotstack](https://composio.dev/toolkits/shotstack) - Shotstack is a cloud platform for programmatically generating videos, images, and audio. Automate creative content production at scale with flexible RESTful APIs.
- [Ticketmaster](https://composio.dev/toolkits/ticketmaster) - Ticketmaster is a global platform for event discovery, ticket sales, and live entertainment management. Get real-time access to events and streamline ticketing for fans and organizers.
- [Gmail](https://composio.dev/toolkits/gmail) - Gmail is Google's email service with powerful spam protection, search, and G Suite integration. It keeps your inbox organized and makes communication fast and reliable.

## Frequently Asked Questions

### What are the differences in Tool Router MCP and Spotify MCP?

With a standalone Spotify MCP server, the agents and LLMs can only access a fixed set of Spotify tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Spotify and many other apps based on the task at hand, all through a single MCP endpoint.

### Can I use Tool Router MCP with LangChain?

Yes, you can. LangChain fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Spotify tools.

### Can I manage the permissions and scopes for Spotify while using Tool Router?

Yes, absolutely. You can configure which Spotify scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

### How safe is my data with Composio Tool Router?

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Spotify data and credentials are handled as safely as possible.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)