pip install mopidyapi==1.1.0



MopidyAPI is a Python (3.6+) library for interacting with Mopidy via its JSON RPC API.

MopidyAPI uses HTTP to call RPC methods, and websockets to listen for events.

It is compatible with all functions present in Mopidy 3.0.1.


pip install mopidyapi


MopidyAPI contains functions mapping to each of the Mopidy v3.0.1 core API functions.

For example mopidy.core.PlaybackController.pause() in the documentation maps to MopidyAPI.playback.pause() here.

Quick example

>>> from mopidyapi import MopidyAPI
>>> m = MopidyAPI()
>>> tracks = m.tracklist.get_tracks()
>>> tracks[0].name

	'I've Seen Footage'

>>> tracks[0].artists

	[Artist(name='Death Grips', uri='spotify:artist:5RADpgYLOuS2ZxDq7ggYYH')]

>>> tracks[0]._fields


Connecting to Mopidy

To connect to Mopidy, you need to instantiate a MopidyAPI object. By default, it will connect to Mopidy at localhost:6680, so you might not need to give the constructor any arguments.

from mopidyapi import MopidyAPI
m = MopidyAPI(host='', port=6680)

You can also pass use_websockets=False, to prevent starting the websocket listener, which runs in a separate thread. However, event listening (described below) won't work with this set.

Calling Mopidy functions

All of the functions described in the Mopidy 3.0.1 core API documentation are available in MopidyAPI.

Functions named in the Mopidy docs as core.<ControllerName>Controller.<functionname>(), will be under the name MopidyAPI.<controllername>.<functionname>()

For example, you can pause the music by calling m.playback.pause(), or you could search for a song by calling e.g.'Rick Astley'), where m = MopidyAPI().

Functions will return Python native namedtuple representations of the returned data.

Event listening

You can use function decorators to mark specific functions to be called when an event arrives. See example below.

The events used are described in Mopidy's core events documentation.

from mopidyapi import MopidyAPI
m = MopidyAPI()

def print_volume(event):
    print(f"Volume changed to: {event.volume}")

def print_newtracks(event):
    print(f"Started playing track: {}")

Like with function calls, the events passed are namedtuples.

If you need to add and remove callbacks more dynamically, you can use the add_callback and del_callback functions.

del_callback accepts two keyword arguments:

  • event: an event name string to remove all callbacks for
  • f: a callback function to remove

You can use one or both. Here's an example of passing a function to del_callback:

from mopidyapi import MopidyAPI
m = MopidyAPI()

def print_volume(event):
    """ Print volume only once. Delete callback after first call """
    print(f"Volume changed to: {event.volume}")

m.add_callback('volume_changed', print_volume)

An important caveat with both the event listener decorators and add methods, is that it will not warn you in any way, if you use an invalid event name (e.g. you misspell the event name).

Note on the choice of namedtuples

Why namedtuples?

The choice of namedtuples might seem unusual (or even inconvenient), but they have a number of advantages over dictionaries for this application:

1. Less verbose than dicts.

is shorter and easier on the eyes than


2. They print much more neatly.

Artist(name='Death Grips', uri='spotify:artist:5RADpgYLOuS2ZxDq7ggYYH')

is much better than

{'name': 'Death Grips', 'uri': 'spotify:artist:5RADpgYLOuS2ZxDq7ggYYH'}.

3. namedtuples accurately represent the immutable nature of the data.

Being allowed to mutate the data coming from Mopidy might give one the idea that this would change the data inside Mopidy, which is obviously not the case.

...but, I know dicts!

Okay, so if you need .keys(), you can use ._fields() instead, and if you absolutely need a dict, you can use ._asdict(), which will return an actual dict.


Please do tell me about bugs via the github issue tracker.

Also feel free to write, if you're just in the mood to help me improve this project. I don't bite :)


This project is licensed under the GPLv3. See the LICENSE file for details.