Skip to content
Klutch.sh Docs

Deploying Snapcast

Introduction

Snapcast is an open-source synchronous multi-room audio solution that enables bit-perfect audio playback across multiple devices with minimal latency. Unlike Bluetooth or Wi-Fi casting, Snapcast ensures all connected speakers play audio in perfect sync, creating a seamless listening experience throughout your home or venue.

Originally designed for home audio enthusiasts, Snapcast has become the go-to solution for anyone wanting synchronized audio without the expense of proprietary multi-room systems. It works with any audio source and any device capable of running a Snapcast client.

Key features of Snapcast include:

  • Perfect Synchronization: Sub-millisecond sync across all connected clients
  • Multi-Room Support: Independent volume and grouping for each room/device
  • Any Audio Source: Works with music players, streaming services, system audio
  • Cross-Platform Clients: Android, iOS, Windows, Linux, macOS, and embedded devices
  • Low Latency: Configurable latency to match your network conditions
  • Lossless Audio: Bit-perfect streaming without quality loss
  • Multiple Streams: Simultaneous streams for different zones
  • JSON-RPC API: Full control for home automation integration
  • Web Interface: Browser-based management and control
  • Open Source: GPLv3 license with active development

This guide walks through deploying the Snapcast server on Klutch.sh using Docker.

Why Deploy Snapcast Server on Klutch.sh

Deploying Snapcast on Klutch.sh provides several advantages:

Central Hub: A reliable, always-on server for your multi-room audio system.

Remote Access: Control your audio system from anywhere with internet access.

Integration Ready: Connect to home automation systems via the API.

Persistent Configuration: Your settings survive restarts and updates.

Scalable Resources: Handle multiple streams and clients.

Important Considerations

Snapcast is primarily designed for local network deployments where low latency is critical. Running the server in the cloud adds network latency that may affect synchronization quality. Consider these factors:

  • Network Latency: Cloud deployment adds latency compared to local hosting
  • Audio Sources: You’ll need to stream audio to the cloud server
  • Client Connectivity: Clients need stable internet connections
  • Best Use Case: Remote management and control rather than primary audio routing

For the best audio experience, consider running Snapcast on a local server with Klutch.sh hosting a control interface or backup configuration.

Prerequisites

Before deploying Snapcast on Klutch.sh, ensure you have:

  • A Klutch.sh account
  • A GitHub account with a repository for your configuration
  • Snapcast clients on your playback devices
  • An audio source (music player, streaming client, etc.)
  • Basic familiarity with Docker and audio streaming

Deploying Snapcast Server on Klutch.sh

    Create a GitHub Repository

    Create a new GitHub repository for your Snapcast configuration.

    Create Your Dockerfile

    Create a Dockerfile:

    FROM alpine:latest
    

    RUN apk add --no-cache snapcast-server
    

    COPY snapserver.conf /etc/snapserver.conf
    

    EXPOSE 1704
    EXPOSE 1705
    EXPOSE 1780
    

    VOLUME /tmp/snapfifo
    

    CMD ["snapserver", "-c", "/etc/snapserver.conf"]

    Create Server Configuration

    Create snapserver.conf:

    [server]
    threads = -1
    datadir = /var/lib/snapserver
    

    [http]
    enabled = true
    bind_to_address = 0.0.0.0
    port = 1780
    doc_root = /usr/share/snapserver/snapweb
    

    [tcp]
    enabled = true
    bind_to_address = 0.0.0.0
    port = 1705
    

    [stream]
    bind_to_address = 0.0.0.0
    port = 1704
    

    [stream:default]
    source = pipe:///tmp/snapfifo?name=default

    Push Your Repository to GitHub

    Commit and push your files.

    Create a New Project on Klutch.sh

    Navigate to the Klutch.sh dashboard and create a new project.

    Create a New App

    Create a new app and connect your GitHub repository.

    Configure Ports

    Snapcast uses multiple ports:

    PortPurpose
    1704Audio streaming (TCP)
    1705Control protocol (TCP)
    1780Web interface (HTTP)

    Configure the HTTP port (1780) for the web interface.

    Attach Persistent Storage

    Add persistent volumes:

    Mount PathRecommended SizePurpose
    /var/lib/snapserver500 MBServer data
    /tmp/snapfifo100 MBAudio FIFO pipe

    Deploy Your Application

    Click Deploy to start the build process.

    Access Web Interface

    Once deployed, access the Snapweb interface at your app’s URL.

    Configure Clients

    Point your Snapcast clients to your server’s address.

Connecting Audio Sources

To send audio to your Snapcast server, you can use various methods:

Local Music Players (on server): Configure music players like MPD, Mopidy, or others to output to the Snapcast FIFO pipe.

Network Streaming: Use tools like PulseAudio or GStreamer to stream audio to the server.

Librespot (Spotify): Configure Librespot to output to Snapcast for Spotify streaming.

Client Setup

Snapcast clients are available for many platforms:

  • Android: Snapcast app from Google Play
  • iOS: Snapcast app from App Store
  • Linux: snapclient package
  • Windows: Snapcast Windows client
  • Raspberry Pi: Perfect for DIY speakers

Additional Resources

Conclusion

Deploying Snapcast on Klutch.sh gives you a central control point for your multi-room audio system. While local deployment typically provides the best latency for audio streaming, a cloud-hosted Snapcast server can serve as a reliable control hub or backup system.

For the best audio experience, consider a hybrid approach: local Snapcast server for actual audio streaming, with Klutch.sh hosting management interfaces or integration endpoints.