Novastar — H Series Api
The blue glow of the server room was the only light in the arena as Elias sat huddled over his laptop. In six hours, the World Championship opening ceremony would begin, but the massive 360-degree LED wrap—the centerpiece of the show—was dark.
He wasn’t just dealing with a simple screen; he was managing a massive cluster of NovaStar H-Series processors. The hardware was capable of handling tens of millions of pixels, but the creative team had just thrown a curveball: they wanted the visuals to react in real-time to the crowd’s noise levels.
"Manual switching won't work," Elias muttered. "I need the API."
He pulled up the H-Series API documentation. He needed to bridge the arena’s sound sensors with the H-Series' powerful layer management. Using a simple Python script, he targeted the H-Series IP address and crafted the JSON payloads. POST /api/v1/scene/switch
His first attempt failed. Connection refused. He checked his port—8000. Correct. He realized he hadn't authenticated the session. He quickly wrapped the request with the proper headers.
The fan noise of the processors hummed in sync with his heartbeat. He wrote a logic loop: if decibels exceeded 90, the API would trigger Scene 2—a high-energy "Voltage" preset. If they hit 110, Scene 3—the "Champion’s Gold" layer—would activate. He hit "Run."
High above, a single pixel line flickered. Then, like a digital sunrise, the entire H9 processor chassis responded. The API command slid the layers into place with zero latency. Elias clapped his hands near the sensor.
Immediately, the massive screen shifted from a deep blue to a pulsing electric violet. "It's alive," he whispered.
When the gates opened and 50,000 fans roared, Elias didn't touch a single button. The H-Series API caught the wave of sound, switching scenes and adjusting brightness automatically. The arena didn't just show a video; it breathed with the crowd, all thanks to a few lines of code and a very powerful processor.
If you'd like to turn this into a technical guide or a specific project, let me know: Which H-Series model are you using (H2, H5, H9, H15)?
Case B: Python Script for Automated Show Control
If you run a live event, you can script the NovaStar H series API to sync with your lighting console (DMX/Art-Net).
import asyncio import websockets import jsonasync def control_novastar_h9(): uri = "ws://192.168.1.100:8088/novastar/api" async with websockets.connect(uri) as websocket: # Login await websocket.send(json.dumps( "jsonrpc": "2.0", "method": "login", "params": "username": "admin", "password": "123456", "id": 1 )) response = await websocket.recv() token = json.loads(response)['result']['token']
# Dim screen for mood lighting await websocket.send(json.dumps( "jsonrpc": "2.0", "method": "display/brightness", "params": "token": token, "value": 10, "id": 2 )) print("Screen dimmed to 10%")
asyncio.run(control_novastar_h9())
Novastar H Series API — Quick Reference & Practical Guide
5. Integration Scenarios
The Future: From API to Ecosystem
The NovaStar H Series API marks a transition from the LED display as a passive screen to an active, managed device within the Internet of Things (IoT). As NovaStar faces competition from companies like Brompton Technology (with its Tessera API) and Colorlight, the robustness of the API becomes a key differentiator. Future iterations will likely embrace RESTful APIs over HTTPS, include better event-driven webhooks (instead of constant polling), and offer SDKs in common languages like Python and C#.
In conclusion, the NovaStar H Series API is a powerful, albeit somewhat guarded, tool for professionals seeking to automate and integrate LED displays. It transforms the receiving card from a dumb data conduit into a smart, networked endpoint. For system architects, display rental companies, and broadcast engineers, mastering this API is no longer optional—it is the key to building resilient, efficient, and innovative visual environments. While documentation and security hurdles remain, the API’s ability to provide granular control over hardware parameters makes it an indispensable asset in the modern LED ecosystem.
The NovaStar H Series API is a robust control interface designed for professional systems integrators who need to automate and manage high-end video wall processors. It primarily uses the HTTP/RESTful protocol, making it highly compatible with modern control systems like Crestron, AMX, and Q-SYS. Core Capabilities
The API allows for comprehensive remote management of the H Series (H2, H5, H9, H15) frames without requiring the physical front panel or the web-based GUI:
Preset Switching: The most common use case; trigger saved layouts and configurations instantly.
Input/Output Management: Query the status of cards, switch signal sources, and manage resolutions. novastar h series api
Layer Control: Dynamically adjust layer positioning, sizing, and priority (Z-order) on the video wall.
System Monitoring: Retrieve real-time data on hardware health, including temperature, power supply status, and card connectivity.
Brightness & Color: Adjust global or screen-specific visual parameters programmatically. Strengths
Standardized Integration: Because it utilizes standard HTTP commands (GET/POST), it is easy for developers to test using tools like Postman before deploying code.
Granular Control: Unlike simpler controllers, the H Series API provides deep access to the modular nature of the hardware, allowing for specific control over individual sub-cards.
Low Latency: Command execution is generally snappy, essential for live event environments where visual transitions must be precise. Considerations for Developers
Documentation Access: NovaStar typically provides the API documentation upon request or via their support portal. It is not always publicly "indexed" like open-source projects.
Security: Implementers should be mindful of network security, as the API allows for significant changes to the visual output; it is best kept on a dedicated, secured AV VLAN.
Version Dependency: Ensure your firmware version matches the API documentation version, as new features (like 16-bit support or specific HDR functions) often require updated command sets. Verdict
The NovaStar H Series API is an essential tool for enterprise-level AV deployments. While the web GUI is excellent for setup, the API is what transforms the H Series from a standalone processor into a fully integrated component of a smart building or broadcast studio.
NovaStar H Series video wall splicers utilize a JSON-based control protocol for third-party integration, allowing developers to manage layers, presets, and device settings over a network. API Connection Methods TCP/IP (Network) : Commands are sent as UDP packets to of the device. RS232 (Serial)
: Standard serial communication using a DB9 or RJ45 adapter, with configurable baud rates through the device web page. Data Format & Syntax
The API uses a specific JSON structure where each command starts with and ends with
. Multiple sub-commands can be nested within a single request using Command Structure Example ["cmd":"W0605","deviceId":0,"screenId":0,"presetId":0] Authentication : Third-party developers must often configure Open API Management in the device's web interface to generate a Project ID Secret Key for authorized requests. Key API Capabilities Layer Operations
: Open, close, move, scale, bring to front, send to back, and switch input sources. Preset Management : Recall saved configurations (presets) by or save the current state as a new preset. Device Status
: Read detailed information, check output lists, and monitor fan speed or voltage. Display Adjustments
: Set brightness, gamma, image quality, and output resolutions. Developer Resources Connection - novastar-h-series - Bitfocus
NovaStar H Series API is a powerful but notoriously "private" control protocol designed for professional AV integration. Unlike standard open-source APIs, it is primarily a UDP-based protocol
that allows third-party controllers (like Crestron or Bitfocus Companion) to manage high-end video wall splicers. The Developer Experience: "Gatekept" and Complex Most developers describe the API as a high-barrier tool. NDA Dependency The blue glow of the server room was
: Official documentation is typically not public. Developers often have to sign an with NovaStar to receive the full control protocol. Documentation Quality
: Reviews from the integration community often label the documentation as challenging
or "useless" for beginners, frequently citing mismatches between the manual and real-world device behavior. Protocol Style : It uses a specific JSON-like command structure sent over UDP port 6000 . A successful command typically returns an "ack": "Ok" Core API Capabilities
For those who navigate the setup, the API offers deep control over the H-Series hardware (H2, H5, H9, H15): Preset Management : The most common use case is recalling presets for live events or corporate lobbies. Layer Control
: Programmatic switching of input sources, layer positioning, and "Take" functions (sending preview to live). Environmental Monitoring : Querying device status, such as temperature, fan speed, and voltage Visual Adjustments : Real-time control of brightness and screen configurations. Community Solutions
Because the official path is difficult, many pros turn to community-built modules: OPEN API or Take Function · Issue #3 - GitHub
The NovaStar H Series video wall splicers utilize an OpenAPI based on the HTTP protocol with JSON data formatting for third-party control . This API allows developers to manage layers, presets, and input sources remotely . API Access & Setup
To begin using the API, you must first enable and configure the project through the device's web interface .
Login: Access the web console using the device's IP address (default is 192.168.0.10) and credentials (default: admin/admin) . Enable API: Navigate to Settings > OpenAPI Management .
Create Project: Click Add to create a new project. The system will automatically generate a pId (Project ID) and a secretKey required for authentication in your requests . Communication Protocol Method: POST . Format: JSON-based instruction set .
Encapsulation: Commands are typically enclosed in brackets (e.g., [ "cmd": "...", ... ]) .
Port: The default control port is 6000 for UDP-based command packets, though standard API interactions often use the HTTP interface . Key API Command Parameters
When constructing commands, you will frequently reference these specific IDs found in the H Series Splicers Control Protocol : inputId: Unique ID for the signal source channel . screenId: The specific screen being controlled .
layerId: ID of the window/layer for positioning and source switching .
presetId: Used to recall or overwrite saved layout configurations . Common Operations
Third-party developers can perform various tasks via the H Series OpenAPI :
Presets: Read currently played presets, edit preset groups, or overwrite existing ones .
Layers: Adjust position (X, Y) and size (Width, Height) coordinates for precise layout control .
IPC Sources: Manage IP Camera source lists, including adding, deleting, or renaming channels . Case B: Python Script for Automated Show Control
Monitoring: Query device status such as temperature, voltage, and connection health .
For detailed command syntax and specific JSON structures, refer to the NovaStar H Series OpenAPI Instructions or the official H Series User Manual .
If you tell me the specific programming language you're using (e.g., Python, C#, JavaScript) or the control system (e.g., Crestron, Q-SYS), I can provide a code snippet for a basic command like switching a preset. H Series Video Wall Splicers User Manual - NovaStar
The third-party developers can control video wall splicers through this connector. Click Add to add a new open API project. H Series OpenAPI Instructions - NovaStar
Master the NovaStar H Series: A Developer’s Guide to the OpenAPI
The NovaStar H Series stands as a flagship all-in-one video splicing processor, specifically engineered for fine-pitch LED applications. For developers and system integrators, its powerful OpenAPI is the key to unlocking seamless automation and custom control. Understanding the H Series API Architecture
The H Series utilizes a modern HTTP-based OpenAPI that communicates using the POST method and JSON data format. Unlike older serial-only protocols, this allows for robust network-based control over standard Ethernet infrastructure. Key Communication Specs: Protocol: HTTP Method: POST Data Format: JSON
Default Port: Often utilizes port 6000 for UDP-based alternate commands. Getting Started: Authentication
To begin using the OpenAPI, you must first obtain your credentials from the device's web management interface:
Log in to the H Series system via a web browser using its IP address (default is typically 192.168.0.10). Navigate to Settings > OpenAPI Management.
Generate or retrieve your pId (Requestor ID) and secretKey. These are essential for authenticating your JSON requests. Core API Capabilities
The H Series API provides granular control over nearly every aspect of the video wall’s operation. Essential commands include:
Preset Management: You can read currently played presets, edit preset groups, and overwrite existing presets.
Layer & Source Control: Switch input sources, select specific screens (by screenId), and manipulate layers (layerId) by resizing or moving them.
Screen Adjustments: Remotely set global brightness (values 0–255), freeze or unfreeze the screen, and trigger "Fade to Black" (FTB).
IPC (IP Camera) Integration: Manage IPC source lists, add/delete channels, and configure IPC mosaic sources for security or monitoring applications.
BKG & OSD: Dynamically create, delete, or update Background (BKG) images and On-Screen Display (OSD) text or images. Real-World Integration Tools
For developers looking for pre-built wrappers or integration modules, several community and official tools exist: H Series - Global leading LED display control solution
Part 5: Critical API Methods for the H Series
Here are the most valuable endpoints for developers working with the H series API. Use these to control your LED wall programmatically.
2. Communication Overview
| Interface | Protocol | Port | Use Case | |-----------|----------|------|-----------| | TCP Raw | ASCII commands | 5000 | Low-latency control, scripting | | HTTP | REST-like | 80 | Web UI integration, status polling | | Serial (RS-232) | Same ASCII set | - | Legacy or isolated systems |
Connection:
- Default IP: 192.168.0.10 (configurable)
- Authentication: None by default (enable password via settings)
