Cloud digital signage platform

Cloud-based digital signage software built for serious operations teams.

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.

How HexitHive works

A simple flow: build content in the portal, push a clean config, and let the players run it locally – even when the WAN misbehaves.

1

Create content & playlists

Upload videos and images into the portal, group them into playlists with durations, and assign them to screens or groups.

2

Accept & push config

When you’re happy, accept the changes. The portal generates a clean player config – no half-finished drag-and-drop edits leaking into production.

3

Players run locally

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.

Want the full technical flow?

See the end-to-end picture from tenants and playlists all the way to player heartbeats and offline behaviour.

Where HexitHive fits best

Built for teams who manage many screens in many places – not just a handful of TVs on one Wi-Fi.

Telco & retail chains

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.

Corporate campuses & offices

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.

Hospitality & QSR

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.

See more detailed scenarios

Dive into how HexitHive behaves in different environments and what it looks like to run screens as part of your existing operations.

Designed for serious operations teams
MSPs & telcos Retail & campus networks Always-on dashboards

What people like about HexitHive

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.”

Future customer quote • NOC / operations lead

“The players don’t panic when the WAN does. They just keep looping the last good playlist and update when the network comes back.”

Future customer quote • Retail / store operations

“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.”

Future partner quote • Managed service provider

Player: Raspberry Pi digital signage engine

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.

What actually runs on the player

Under the TV there’s a Raspberry Pi running a minimal Linux stack with three key pieces:

  • Local API service (Python) on 127.0.0.1:7680 that exposes endpoints like /device, /player/playlist and /player/sync.
  • Playback loop that reads a JSON playlist and hands each item to the media engine (mpv) in full-screen digital signage mode.
  • State & cache under /var/lib/hexithive for device.json (identity, pairing, PIN) and a content/ folder of cached videos and images.

How it boots and starts playback

On power-on the Pi boots Linux, shows a branded splash screen, then systemd brings up the player stack:

  • Step 1: Local API starts, reads or initialises /var/lib/hexithive/device.json.
  • Step 2: The player process connects to the local API and requests the current digital signage playlist.
  • Step 3: In the background, the local API calls the HexitHive portal to sync config and download any new media files.
  • Step 4: Once at least one playable item is present, the playback loop starts and the screen goes live.

Offline-safe by design

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.

Player data flow
Portal
Playlists & media
HTTPS APIs
/api/player/config.php
Local API
127.0.0.1:7680
Player loop
mpv + timings
Screen
HDMI output

Maintenance & wizard

A 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.

Heartbeats & health

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.

Security model

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.

Portal: multi-tenant digital signage control plane

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.

Tenant & screen hierarchy

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.

  • Tenants define the top-level boundary for data, branding, limits and billing.
  • Companies / locations group screens logically: “Mall A / Food Court”, “Branch 01 / Reception”.
  • Screens represent the individual Raspberry Pi players and their assigned digital signage playlists.
  • Users & roles (admin, operator, viewer) control who can change playlists, approve devices or just monitor health.

From playlist edits to published configs

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.

  • Media: managed assets with metadata and tenant scoping.
  • Playlists: ordered lists of items with durations and rules.
  • Assignments: which playlist is “live” for each screen.
  • Published configs: frozen JSON snapshots that the players download via /api/player/config.php.

Designed for operations & NOCs

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.

Tenant
HexitHive Root
Limits, branding, owner
Companies / customers
Customer A
Branches, cost centres
Customer B
Multiple locations
Screens
Screen 01
Linked to device_key
Screen 02
Reception / lobby
Screen 03
Menu board
Playlists & configs
Playlists
“Reception Loop”, “Breakfast Menu”
Published configs
JSON snapshots per screen
Multi-tenant by design
Isolate customers

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.

Screen-centric monitoring
Per-screen status

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.

Controlled rollouts
Publish configs

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”.

Simple per-screen pricing

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.

Predictable billing

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.

Partner-friendly

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.

Straightforward rollout

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.

HexitHive digital signage FAQ

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.

For architects, operators & security teams

If you care about networks, failure modes and how this fits into your monitoring and ITSM stack, these pages are for you.

Platform architecture

High-level view of the HexitHive control plane (Portal), player layer and APIs: how tenants, screens, playlists and heartbeats fit together.

Read the architecture overview

Use cases & resources

Concrete deployment patterns for MSPs, enterprises and retail, plus a central hub where future docs and API references will live.

Browse use cases · Open the resources hub

Talk to us about your digital signage footprint

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.

Or email us directly at support@synergetix.co.za if you prefer.