Create content & playlists
Upload videos and images into the portal, group them into playlists with durations, and assign them to screens or groups.
HexitHive combines a hardened Raspberry Pi player with a multi-tenant web portal, so you can manage digital signage screens the same way you manage the rest of your infrastructure: predictably, securely, and with clear health signals.
A simple flow: build content in the portal, push a clean config, and let the players run it locally – even when the WAN misbehaves.
Upload videos and images into the portal, group them into playlists with durations, and assign them to screens or groups.
When you’re happy, accept the changes. The portal generates a clean player config – no half-finished drag-and-drop edits leaking into production.
Raspberry Pi players fetch configs and media over HTTPS, cache them locally and keep playing from local disk while sending regular heartbeats back to the portal.
See the end-to-end picture from tenants and playlists all the way to player heartbeats and offline behaviour.
Built for teams who manage many screens in many places – not just a handful of TVs on one Wi-Fi.
Mirror your branch structure in the tenant tree, give each region or store clear admin rights, and monitor health across hundreds of screens.
Perfect for promos, campaigns and standardised in-store branding.
Lobby screens, canteens, lift lobbies and office floors – all fed from a central portal, with local IT able to see status and run basic checks.
Internal comms teams get a clean way to manage content without touching the infrastructure details.
Menu boards and promo screens that keep working through flaky mall Wi-Fi. Update specials centrally, let stores stay focused on service.
Offline-safe players keep the last good playlist running until connectivity returns.
Dive into how HexitHive behaves in different environments and what it looks like to run screens as part of your existing operations.
Placeholder quotes for now – real names and logos can follow as pilots and early adopters go live.
“It behaves like an ops tool, not a toy. We can see which screens are healthy and what config they’re actually running.”
“The players don’t panic when the WAN does. They just keep looping the last good playlist and update when the network comes back.”
“Multi-tenant from the start makes it a much easier fit for an MSP model. We can keep customers cleanly separated without building our own glue.”
Each HexitHive screen runs on a Raspberry Pi with a local API, cached media and a tight playback loop. The player is built to behave like any other production service: predictable startup, clear health signals and safe behaviour when the network misbehaves.
Under the TV there’s a Raspberry Pi running a minimal Linux stack with three key pieces:
127.0.0.1:7680 that
exposes endpoints like /device, /player/playlist and
/player/sync./var/lib/hexithive for
device.json (identity, pairing, PIN) and a
content/ folder of cached videos and images.On power-on the Pi boots Linux, shows a branded splash screen, then systemd brings up the player stack:
/var/lib/hexithive/device.json.If the internet or the portal is unavailable, the player simply keeps using the last known good playlist and local media cache. Heartbeats to the portal will fail, but the digital signage screen keeps playing. This is exactly what you want for branch sites, retail and remote locations.
/api/player/config.php127.0.0.1:7680A local wizard and maintenance screen give field techs the essentials: hostname, IP, pairing status, last config sync and the ability to trigger a manual resync or safe reboot using a maintenance PIN.
The player posts regular heartbeats via the local API to
/api/player/heartbeat.php, including last-seen time,
playlist ID and basic health data. The portal turns this into
clear “online / offline / stale” signals per digital signage screen.
Players initiate outbound HTTPS only, identified by a random
device_key. The local API is bound to localhost and
sensitive state is stored under root-owned paths on the Pi.
There’s no need to poke inbound firewall holes into customer sites.
The HexitHive portal is the central brain: it knows which tenants exist, which screens belong to which customer, what content should be playing and what the health of each player looks like. It is built for MSP-style environments where you might manage dozens of customers and hundreds of screens.
Everything starts with a tenant. Under that tenant you manage companies,
users and screens. Each screen is a physical device out in the field with
a device_key that ties it back to the portal.
Inside the portal you work with familiar objects: media files and playlists. You upload videos and images once, build playlists per tenant and then publish those changes into a per-screen configuration that players actually consume.
/api/player/config.php.The portal exposes the things operations teams care about: last heartbeat, last config push and how many screens are currently healthy, stale or dark. You can drill into an individual screen to see its history and current playlist, instead of guessing what content “should be” playing.
Each tenant has its own screens, playlists, users and limits. Operators see only the tenants they’re allowed to manage, which keeps MSP environments clean and auditable.
Screens are first-class citizens: last heartbeat, last config push and alert-friendly states such as “online”, “offline” and “stale”. No more guessing what the TV is doing in another city.
Playlist edits can be staged and then pushed, generating new published configs that players consume. That gives you a clear boundary between “saved in the UI” and “live on the TV”.
HexitHive is designed to slot into existing MSP and enterprise models. You pay per active digital signage screen, with room for partner tiers and private pricing once we know your footprint.
Pricing is based on the number of active screens under management, not the number of users. That maps cleanly to how you already think about sites, branches and locations.
The platform is built with resellers and MSPs in mind: a single portal, many tenants and the ability to separate your internal HexitHive Root tenant from customer tenants.
Start with a small pilot, then standardise: one Raspberry Pi image, consistent portal onboarding and a repeatable process for pairing new players to the right tenant and screen.
A few of the common questions we see when teams move from ad-hoc media players to a proper digital signage platform with a managed player stack.
If you care about networks, failure modes and how this fits into your monitoring and ITSM stack, these pages are for you.
High-level view of the HexitHive control plane (Portal), player layer and APIs: how tenants, screens, playlists and heartbeats fit together.
Tenant isolation, device identity, HTTPS-only APIs, offline playback and how players behave when networks misbehave.
Concrete deployment patterns for MSPs, enterprises and retail, plus a central hub where future docs and API references will live.
Whether you’re running a handful of office dashboards or hundreds of retail and campus screens, we can walk you through how HexitHive would slot into your existing monitoring and operations stack.