Skip to content

Me

Get Current User's Profile

client.me.retrieve(?): MeRetrieveResponse { id, country, display_name, 10 more }

GET/me

MeAudiobooks

Get User's Saved Audiobooks

client.me.audiobooks.list(?, ?): CursorURLPage<AudiobookListResponse { added_at, audiobook, published } >

GET/me/audiobooks

Save Audiobooks for Current User

client.me.audiobooks.save(, ?): void

PUT/me/audiobooks

Remove User's Saved Audiobooks

client.me.audiobooks.remove(, ?): void

DELETE/me/audiobooks

Check User's Saved Audiobooks

client.me.audiobooks.check(, ?): AudiobookCheckResponse

GET/me/audiobooks/contains

MePlaylists

Get Current User's Playlists

client.me.playlists.list(?, ?): CursorURLPage<SimplifiedPlaylistObject { id, collaborative, description, 10 more } >

GET/me/playlists

MeTop

Get User's Top Tracks

client.me.top.listTopTracks(?, ?): CursorURLPage<TrackObject { id, album, artists, 18 more } >

GET/me/top/tracks

Get User's Top Artists

client.me.top.listTopArtists(?, ?): CursorURLPage<ArtistObject { id, external_urls, followers, 8 more } >

GET/me/top/artists

MeAlbums

Get User's Saved Albums

client.me.albums.list(?, ?): CursorURLPage<AlbumListResponse { added_at, album, published } >

GET/me/albums

Save Albums for Current User

client.me.albums.save(?, ?): void

PUT/me/albums

Remove Users' Saved Albums

client.me.albums.remove(?, ?): void

DELETE/me/albums

Check User's Saved Albums

client.me.albums.check(, ?): AlbumCheckResponse

GET/me/albums/contains

MeTracks

Get User's Saved Tracks

client.me.tracks.list(?, ?): CursorURLPage<TrackListResponse { added_at, published, track } >

GET/me/tracks

Save Tracks for Current User

client.me.tracks.save(, ?): void

PUT/me/tracks

Remove User's Saved Tracks

client.me.tracks.remove(?, ?): void

DELETE/me/tracks

Check User's Saved Tracks

client.me.tracks.check(, ?): TrackCheckResponse

GET/me/tracks/contains

MeEpisodes

Get User's Saved Episodes

client.me.episodes.list(?, ?): CursorURLPage<EpisodeListResponse { added_at, episode, published } >

GET/me/episodes

Save Episodes for Current User

client.me.episodes.save(, ?): void

PUT/me/episodes

Remove User's Saved Episodes

client.me.episodes.remove(?, ?): void

DELETE/me/episodes

Check User's Saved Episodes

client.me.episodes.check(, ?): EpisodeCheckResponse

GET/me/episodes/contains

MeShows

Get User's Saved Shows

client.me.shows.list(?, ?): CursorURLPage<ShowListResponse { added_at, published, show } >

GET/me/shows

Save Shows for Current User

client.me.shows.save(?, ?): void

PUT/me/shows

Remove User's Saved Shows

client.me.shows.remove(?, ?): void

DELETE/me/shows

Check User's Saved Shows

client.me.shows.check(, ?): ShowCheckResponse

GET/me/shows/contains

MeFollowing

Get Followed Artists

client.me.following.bulkRetrieve(, ?): FollowingBulkRetrieveResponse { artists }

GET/me/following

Follow Artists or Users

client.me.following.follow(, ?): void

PUT/me/following

Unfollow Artists or Users

client.me.following.unfollow(?, ?): void

DELETE/me/following

Check If User Follows Artists or Users

client.me.following.check(, ?): FollowingCheckResponse

GET/me/following/contains

MePlayer

Get Playback State

client.me.player.getState(?, ?): PlayerGetStateResponse { actions, context, currently_playing_type, 8 more }

GET/me/player

Transfer Playback

client.me.player.transfer(, ?): void

PUT/me/player

Get Available Devices

client.me.player.getDevices(?): PlayerGetDevicesResponse { devices }

GET/me/player/devices

Get Currently Playing Track

client.me.player.getCurrentlyPlaying(?, ?): PlayerGetCurrentlyPlayingResponse { actions, context, currently_playing_type, 5 more }

GET/me/player/currently-playing

Start/Resume Playback

client.me.player.startPlayback(?, ?): void

PUT/me/player/play

Pause Playback

client.me.player.pausePlayback(?, ?): void

PUT/me/player/pause

Skip To Next

client.me.player.skipNext(?, ?): void

POST/me/player/next

Skip To Previous

client.me.player.skipPrevious(?, ?): void

POST/me/player/previous

Seek To Position

client.me.player.seekToPosition(, ?): void

PUT/me/player/seek

Set Repeat Mode

client.me.player.setRepeatMode(, ?): void

PUT/me/player/repeat

Set Playback Volume

client.me.player.setVolume(, ?): void

PUT/me/player/volume

Toggle Playback Shuffle

client.me.player.toggleShuffle(, ?): void

PUT/me/player/shuffle

Get Recently Played Tracks

client.me.player.listRecentlyPlayed(?, ?): CursorURLPage<PlayerListRecentlyPlayedResponse { context, played_at, published, track } >

GET/me/player/recently-played

ModelsExpand Collapse

ContextObject { external_urls, href, published, 2 more }

external_urls?: ExternalURLObject { published, spotify }

External URLs for this context.

published?: boolean

The playlist's public/private status (if it should be added to the user's profile or not): true the playlist will be public, false the playlist will be private, null the playlist status is not relevant. For more about public/private status, see Working with Playlists

spotify?: string

The Spotify URL for the object.

href?: string

A link to the Web API endpoint providing full details of the track.

published?: boolean

The playlist's public/private status (if it should be added to the user's profile or not): true the playlist will be public, false the playlist will be private, null the playlist status is not relevant. For more about public/private status, see Working with Playlists

type?: string

The object type, e.g. "artist", "playlist", "album", "show".

uri?: string

The Spotify URI for the context.

DeviceObject { id, is_active, is_private_session, 6 more }

id?: string | null

The device ID. This ID is unique and persistent to some extent. However, this is not guaranteed and any cached device_id should periodically be cleared out and refetched as necessary.

is_active?: boolean

If this device is the currently active device.

is_private_session?: boolean

If this device is currently in a private session.

is_restricted?: boolean

Whether controlling this device is restricted. At present if this is "true" then no Web API commands will be accepted by this device.

name?: string

A human-readable name for the device. Some devices have a name that the user can configure (e.g. "Loudest speaker") and some devices have a generic name associated with the manufacturer or device model.

published?: boolean

The playlist's public/private status (if it should be added to the user's profile or not): true the playlist will be public, false the playlist will be private, null the playlist status is not relevant. For more about public/private status, see Working with Playlists

supports_volume?: boolean

If this device can be used to set the volume.

type?: string

Device type, such as "computer", "smartphone" or "speaker".

volume_percent?: number | null

The current volume in percent.

minimum0

maximum100

MePlayerQueue

Get the User's Queue

client.me.player.queue.get(?): QueueGetResponse { currently_playing, published, queue }

GET/me/player/queue

Add Item to Playback Queue

client.me.player.queue.add(, ?): void

POST/me/player/queue