简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Mopidy?
Mopidy is an extensible music server written in Python. It runs on a Linux computer or Mac with network connectivity and audio output, playing music from local files and Internet radio out of the box, with extensions adding cloud services and other sources. It is a server, not a player app: you control it from separate MPD or web clients on phones, tablets, or computers, and several people can connect at once to share a playlist.
How it is typically used
- Home audio on a small computer: Install it on a Raspberry Pi running Raspberry Pi OS, Ubuntu, or Arch Linux, connect speakers, and leave it running in the background as an always-on music box.
- Multi-source playback: Local files and Internet radio work without extra setup; extensions add backends for services such as Spotify, SoundCloud, and radio networks.
- Shared control: Anyone on the network can search and queue music from their own device using an MPD or web client, which suits shared rooms and households.
- Custom projects: Python, JSON-RPC, and JavaScript APIs let you build your own frontends or control hardware. The site's cassette-player example wires GPIO buttons and NFC tags to a custom extension for Spotify playlists.
Trade-offs to expect
| Aspect | What it means for you |
|---|---|
| Server plus client | You must choose and install a client; there is no built-in phone app or desktop player. |
| Extension-based features | Cloud services and extra frontends depend on extensions, which you install and maintain separately. |
| Command-line install | Setup happens in a terminal on Linux or macOS; it is not a one-click consumer app. |
| Hardware-friendly | Runs well on low-power boards like the Raspberry Pi, but you supply the computer, audio output, and network. |
If you just want to press play on a phone, a mainstream streaming app is simpler. If you want a headless, hackable music server feeding your own speakers and controllable from any device in the house, Mopidy fits that role well.
A practical next step: check the official extension list to confirm the sources and clients you need are supported before installing, then start with local files and Internet radio to verify audio output before adding cloud backends. For reference beyond the project itself, see Raspberry Pi if you plan to use a Pi as the host.
How do I install Mopidy on a Raspberry Pi?
Mopidy is a headless Python music server, so installing it on a Raspberry Pi means installing a background service and a client to control it — not a desktop music app. The official docs recommend Raspberry Pi OS, Ubuntu, or Arch Linux as the base system, and Pimoroni specifically recommends Mopidy for use with its Pirate Audio audio gear.
The basic shape of an install
- Start with a supported OS image (Raspberry Pi OS, Ubuntu, or Arch Linux) and get audio output working first.
- Install Mopidy itself, then install extensions for the sources you actually use — out of the box it plays local files and Internet radio; cloud services and radio networks come via extensions.
- Install a frontend. Mopidy is an HTTP server by default; adding the Mopidy-MPD extension makes it an MPD server too, which is what most MPD clients expect.
- Connect a client from any phone, tablet, or computer on the same network to search and manage the playlist.
Choosing how to install
| Route | Best for | Trade-off |
|---|---|---|
| Official install docs for your distro | Most users; keeps packages managed | You follow distro-specific steps |
| Raspberry Pi OS packages where available | Quick start on a standard Pi image | May lag the newest Mopidy release |
| Running from source / pip in a virtualenv | Testing new versions or writing extensions | You manage updates and dependencies yourself |
For a first install, use the official instructions rather than improvising — the project publishes install and reference docs at Mopidy, and the community forum at Mopidy Discourse is where distro-specific snags get answered.
Practical next step
Decide your control client before you install anything else. Mopidy-Iris is a well-known web frontend, and MPD clients exist for all popular operating systems, so you can pick one that matches the devices in your household. Then install Mopidy, add Mopidy-MPD plus your source extensions, and confirm you can reach the web interface from another device before adding cloud accounts.
If you want hardware controls, the project's own example is a Pi embedded in an old cassette player, with GPIO-wired buttons and volume plus a custom extension — a reminder that Mopidy's Python, JSON-RPC, and JavaScript APIs are the reason it suits tinkering rather than being a locked-down appliance.
Which MPD or web clients can I use to control Mopidy?
Mopidy itself is only the server; the client you use is a separate piece of software that connects to it. Any MPD-compatible client can control playback once the Mopidy-MPD extension is installed, and web clients typically run as additional Mopidy extensions you open in a browser.
MPD clients
Because Mopidy speaks the MPD protocol through the Mopidy-MPD extension, the practical answer is: use whatever MPD client you already like. MPD clients exist for phones, tablets, desktops and Linux boxes, so the same server can be driven from several devices at once — useful when everyone in a room wants to queue tracks. If you already have a favourite MPD app, start there rather than hunting for a Mopidy-specific one.
Web clients
Web frontends are distributed as Mopidy extensions, so you install the one you want and then open it in a browser on any phone, tablet or computer on the network. The page names Mopidy-Iris by James Barnsley as one such client. This is the easier route if you would rather not install a separate app, and it works well on a Raspberry Pi setup where you just want a browser tab as the remote control.
How to choose
| Situation | Sensible choice |
|---|---|
| You already use an MPD app you like | Keep it; just enable Mopidy-MPD |
| You want no extra app installs | A web frontend extension in a browser |
| Several people control one speaker | Any combination — MPD and web clients can connect simultaneously |
| Raspberry Pi in a fixed location | Web client on a phone, or an MPD client for a more app-like feel |
A concrete scenario: run Mopidy on a Raspberry Pi connected to speakers, add Mopidy-MPD plus a web frontend, then let one person queue music from a phone browser while another uses their preferred MPD app on a laptop. Both see and edit the same playlist.
To decide, check whether your chosen client supports the features you rely on — search, queue editing and playlist management are the common ones — then browse the extensions list on Mopidy to confirm the frontend is available and install it alongside Mopidy-MPD.
How can I add Spotify or other cloud music services to Mopidy?
Install an extension for each service. Mopidy itself ships playing local files and Internet radio; Spotify, SoundCloud and similar cloud sources arrive as separate backend extensions that you enable in Mopidy's configuration. Mopidy's own page lists Spotify and SoundCloud among the services extensions can add, and notes that new backends are how you extend the source list.
The typical path is:
- Install Mopidy and confirm it plays a local file or radio stream.
- Find the extension for your service in the extension registry linked from Mopidy.
- Install it with the same package manager you used for Mopidy (often
pip, or your distribution's packages). - Enable it in the config file — usually by adding it to
enabled_extensionsand filling in service-specific settings such as credentials. - Restart Mopidy and check the log for authentication or backend errors.
- Connect a client and confirm the service appears as a browsing source.
The trade-offs differ by service. Spotify support depends on the extension's own authentication and may require a premium account or developer credentials; radio and local files need no account at all. Community-maintained extensions can lag behind service API changes, so a working setup may need updating after a service changes its terms.
For a concrete case: someone running Mopidy on a Raspberry Pi in a kitchen can keep local albums and Internet radio working out of the box, then add Spotify via an extension so guests can search and queue from their phones with an MPD or web client, without changing the hardware.
Next step: pick your service, check its extension's documentation for the exact config keys, and test with one source before adding more — that isolates whether a failure is the extension or your client setup.
Can multiple people control the same Mopidy playlist at once?
Yes. Mopidy is designed as a shared server, so several people can connect their own clients to the same instance and search for music, queue tracks, and edit the playlist together. The page describes this directly: “You and the people around you can all connect their favorite MPD or web client to the Mopidy server to search for music and manage the playlist together.”
What that looks like in practice
- One person runs Mopidy on a Linux computer, Mac, or Raspberry Pi with network access and audio output.
- Everyone else connects over the network using an MPD client or a web client, on phones, tablets, or computers.
- Because Mopidy is “just a server,” the clients are separate from the music engine. Mopidy itself does not have a single built-in screen that everyone crowds around; each person brings their own app.
- Out of the box Mopidy acts as an HTTP server. Adding the Mopidy-MPD extension makes it an MPD server as well, which is what many third-party clients expect.
The trade-offs to expect
Shared control is genuinely collaborative, but it is not the same as separate user accounts with private queues. Everyone connected to the same Mopidy instance is generally working with the same playback state and playlist. If two people add tracks or skip songs at the same time, the result reflects that shared state. For a household, office, cafe, or party, that is usually the point. For a situation where each person wants their own independent queue, you would need separate Mopidy instances rather than one shared server.
A useful next step
Decide who will host the server and where the audio comes out, then choose clients per person. If your group already uses MPD-compatible apps, install the Mopidy-MPD extension and everyone can connect with what they have. For a browser-based shared experience, look at web frontends such as Mopidy-Iris. To see what fits your setup, browse the extension list on Mopidy and check the documentation for client and backend compatibility.
How do I build a custom extension or project with Mopidy's APIs?
Build the extension as a normal Python package that plugs into Mopidy's extension mechanism, then decide which API surface you actually need: a backend if you are adding a music source, a frontend if you are adding a control surface, or both if the project is a self-contained appliance.
Mopidy itself is a Python application that runs in a terminal or in the background on Linux or macOS with network connectivity and audio output. Out of the box it is an HTTP server; installing the Mopidy-MPD extension turns it into an MPD server as well. Other frontends arrive as extensions. That architecture matters for your project: you are not modifying a monolith, you are registering components that the core server loads.
Pick the extension type first
- Backend extension — add a new music source. Mopidy plays local files and Internet radio by default; cloud services and radio networks are added through extension backends. This is the path for a service Mopidy does not already support.
- Frontend extension — add a way to control playback, search or manage the playlist. Mopidy exposes HTTP and, with Mopidy-MPD, MPD; additional frontends are extensions.
- Mixed or appliance project — a backend plus a frontend plus hardware glue. The cassette-player hack on Mopidy's site is exactly this: a Raspberry Pi in an old cassette player, buttons and a volume control wired through GPIO to control playback via a custom Mopidy extension, and NFC tags on cassettes used to select Spotify playlists.
Use the API level that fits the job
Mopidy's extension support and its Python, JSON-RPC and JavaScript APIs are the documented base for projects. In practice:
- Python API — for code running inside the Mopidy process, i.e. backends and frontends packaged as extensions. Best when you need tight coupling to playback, the tracklist or the library.
- JSON-RPC — for a separate process or service that wants to query and control Mopidy over the network without importing Mopidy internals. Good for a web dashboard, a home-automation bridge or a script.
- JavaScript API — for browser-based control interfaces, typically alongside the HTTP server and a web client.
If you are unsure, start with JSON-RPC. It keeps your project decoupled and testable, and you can move logic into a Python extension later if you need lower-level access.
A practical build order
- Install Mopidy and confirm it plays local files and Internet radio before writing any code.
- Enable Mopidy-MPD so you have a known-good control channel to test against.
- Scaffold your extension as a Python package with an entry point that Mopidy discovers, and get it to load with no functionality.
- Implement the smallest useful behaviour — one search method, one playback action — and verify it through an existing MPD or web client rather than a bespoke test harness.
- Add configuration, error handling and packaging, then test on the target machine.
Choose your hardware with the audience in mind
A Raspberry Pi is the approachable target: Mopidy runs on Raspberry Pi OS, Ubuntu or Arch Linux, and Pimoroni recommends Mopidy for use with its Pirate Audio audio gear for the Pi. For a personal project or a gift, a Pi plus a supported audio HAT removes most of the audio-configuration pain. For a desktop-only project, Linux or macOS with a working audio output is enough.
Where to read and ask
- Mopidy — the home page summarises the server, extension model and example hacks.
- Mopidy Documentation — the reference for APIs, extension structure and configuration.
- Mopidy Discourse — the community forum for extension-development questions.
- GitHub — Mopidy's own source and existing extensions are the most reliable worked examples of the extension pattern.
Next step: read the extension documentation end to end, then read the source of one small existing backend and one small frontend before writing your own. Copying a working extension's structure is faster and less error-prone than starting from a blank package.
Cloudflare
Fastly
User reviews (0)