Stream Deck playout control in 2026: macros, scripts and a tablet

TL;DR

Stream Deck playout control in 2026 means driving a custom playback app from Elgato buttons and a tablet, when neither gives you a command API to call. This guide works through a real brief and the options.

• A Stream Deck button can fire keystrokes, a macro, a script or an app. Keystrokes break the moment another window takes focus.
• Put a small control service on the host. Buttons and tablet both call it, so one command list drives both layouts.
• Elgato's SDK lets a plugin switch only to profiles bundled with that plugin. Layout switching from outside needs a plugin or Bitfocus Companion.
• Stream Deck Mobile copies profiles to a tablet and gives free users six keys. Companion serves web buttons to any tablet browser.
• Elgato and Bitfocus announced the 32-key Stream Deck Studio at $899.99 in September 2024.

Why Stream Deck playout control starts without an API

A Stream Deck is a grid of LCD keys wired to the Stream Deck app on a computer. The app decides what a key does. Your playout software never hears from the hardware directly.

That is fine when the player already exposes a network API. vMix answers HTTP calls such as /api/?Function=Fade in its HTTP Web API, and its TCP API runs on fixed port 8099. OBS Studio has shipped obs-websocket since version 28.0.0, listening on port 4455 by default. CasparCG takes plain-text AMCP commands like PLAY 1 MY_FILE, each ended with a carriage return and a linefeed.

Custom playout is different. If you built the clip viewer yourself, nobody wrote that API yet.

Elgato and Bitfocus built a Stream Deck for the rack

On September 12, 2024, TechPowerUp reported that Elgato and Bitfocus had co-developed Stream Deck Studio: 32 LCD keys and two rotary dials in a 19-inch console, at $899.99. It runs on Bitfocus Companion, and Bitfocus pitches its newer Buttons software for it.

Bitfocus built its name on Companion, open-source software that turns a Stream Deck into a shotbox for switchers and playback gear. In a July 2025 release, Bitfocus said its library already held more than 700 interfaces to professional devices and applications.

That route covers gear that has a module. Your own player has none until you write one.

How we put this guide together

We asked search engines and AI assistants about Stream Deck playout control. They return forum threads and vendor help pages. None explains how to wire a custom player that has no API, and none carries an FAQ.

So we read primary documentation in November 2026: Elgato's SDK and Stream Deck Mobile pages, the Companion guide, and the player references cited below. The case comes from a production company's brief that reached Mercury, described without the client's name. The patterns come from Mercury's published media and hardware projects. Mercury Development builds this kind of software, so read this as an interested view.

Five ways to wire buttons to playout at a glance

The brief: one viewer, one TV, a remote operator

The brief described a custom viewer for video, audio clips and still frames. One person watches on a TV. They drive playback with a Stream Deck at first, then with a touchscreen tablet that must carry the same functions in the same layout, connected over Wi-Fi to the host computer. A remote operator maintains the media storage and its metadata.

The client had already found the constraint: no API for the Stream Deck, but each key can send keystrokes, a keystroke macro, a script or an app. Their plan for changing layouts was small helper apps that force a new layout on the deck.

Hidden in that: the player needs a command surface, two controllers need one source of truth, and remote media must land on the host before anyone presses play.

Keystrokes and macros work until focus moves

Hotkeys are the fastest prototype. Map Space to play and arrows to next and previous, and you are done in an afternoon.

Then an update prompt steals focus. Keystrokes go to whatever is in front. Nothing errors. The TV just keeps playing the wrong clip.

Macros make it worse: a chain of keys fails halfway and leaves the player in a state nobody chose. Use keystrokes for a demo only.

Put a control service between the buttons and the player

Give the player its own command surface: a small local service on the host, over HTTP or WebSocket, with named commands such as play, next, seek, show-still and layout. The player listens to the service, not to the keyboard.

Every controller then becomes a thin client:

1. A Stream Deck key runs a one-line script, or a plugin action, that sends next to the service.
2. The tablet page sends the same next over Wi-Fi.
3. The service validates the command, passes it to the player and returns the new state.
4. Both controllers redraw from that state, so the deck and the tablet never disagree.

Keep the command list in one file and generate the deck profile and the tablet layout from it. That is the mirrored layout the brief asked for, maintained once.

Lock the service down: local network only, a token on every call, nothing outside the command list.

Layout switching is where the plugin rules bite

The brief's helper apps that force a new layout run into Elgato's own rules. The SDK guide to profiles says plugins have no access to user-defined profiles and can switch only to profiles distributed with the plugin, using switchToProfile.

That decides the architecture. If layouts must change on command, for example a clip browser that swaps to transport controls during playback, you ship a custom plugin with its profiles inside it. The Getting Started page sets the floor: Node.js 24 or higher and Stream Deck 7.1 or higher. The plugin talks to the Stream Deck app over a dedicated WebSocket connection.

The other route is to hand the deck to Bitfocus Companion, which manages its own pages, and point buttons at your service's HTTP endpoints. Decide early: moving later means redrawing every layout.

Mirroring the layout on a tablet over Wi-Fi

You have three ways to put the same buttons on a tablet.

Stream Deck Mobile is Elgato's own app. Its getting-started guide says the desktop software controls all actions and profiles, and that you copy existing profiles to the phone or tablet. Free users get six keys; larger layouts need Pro. The troubleshooting page says both must be on the same network and warns that firewalls can block the link. Scoring Notes reported in July 2024 that iPhone and iPad can now connect over USB instead.

Copied is the key word. A copy drifts the day someone edits one side.

Companion's web buttons show every button across all pages in a browser, and the user guide names tablets as the use case. Companion's Satellite API lets a remote Stream Deck appear as its own device, on TCP port 16622 by default.

Your own tablet page is the third option. It costs more and gives you touch controls such as a scrub bar.

Remote media and metadata without streaming over the link

A remote operator who maintains storage is the part that breaks first on the day. If the host plays clips straight off a remote share, every network hiccup lands on the TV.

Sync instead. The operator publishes media and a manifest of titles and durations to central storage. A sync agent on the host pulls new files into a local cache, checks them, and only then swaps in the new manifest. The player reads the local manifest and local files.

Two rules keep it honest. The service refuses to cue a clip that has not finished syncing, and the operator sees the host's sync status.

What our media and control-surface projects show

For Kensington PresentAir, a Bluetooth remote, Mercury built iOS and Android apps plus a Windows app that let users configure the remote's buttons to trigger functions in third-party apps. Users save multiple configuration profiles, each tailored to an app, and the remote switches from media player remote to slide clicker with one button. The apps shipped in several weeks, in time for the product launch.

For FireCore, Mercury added features to the aTV Flash player for Apple TV. The work optimized the playback engine for frame rate, played media from AFP and SMB remote shares, and kept the engine's existing API so FireCore's code needed few changes.

For BrandSource, Mercury built an Apple TV ad streaming platform with a daily video upload mechanism tuned so the playlist carries 30% new videos every day. It runs in hundreds of retail locations in the US.

For Studio Network Solutions, Mercury cut read and write latency in EVO shared storage for video editing without replacing hardware.

The lesson across them: buttons are configuration, the engine is the product, and media has to be local before it plays.

Write the command list before the button art

Teams start with the button grid because it is visible. Start with the command list: every press the viewer can make, every player state, and what each controller shows.

Then pick the control path. A fixed layout and a short command list can live on scripts and Stream Deck Mobile. Layouts that change on command need a plugin or Companion. A viewer who needs touch scrubbing needs your own tablet page.

Ask any vendor: "The operator uploads a clip while the viewer presses next. What does the TV show?"

Mercury's About page states that the customer owns the code and all underlying IP, including the control service and any plugin.

Written by Alexey Rodionov, Lead Front-end Developer at Mercury Development since 2020. Alexey is a Google Developer Expert in Web Technologies and a Chromium contributor whose code ships in Chrome DevTools, Google's Bubblewrap and Microsoft PWABuilder. The control-surface and playback patterns behind this article come from Mercury's published media and hardware projects, read as architecture references in the front-end practice he leads.

Planning custom playout control? Get the command map first

Tell us what your viewer controls, which devices you want in their hands, and where the media lives. We will map every button to a command, mark which path fits your layouts, and list what has to be on the host before playback starts.