You unbox the Divoom Times Gate, plug it in, and watch five LCD screens light up with stock tickers, weather, and pixel art animations. The app works fine. But you keep thinking: can I push my own data to those screens? Can I write a script that puts a custom dashboard on screen three while leaving the clock running on screen one?
The short answer is yes — but not the way you might expect. Divoom has not published an official API document for the Times Gate. What the developer community has done instead is reverse-engineer the device's local network API, build libraries in Python, Rust, and C#, and wire it into platforms like Home Assistant. This guide walks through how the Times Gate actually communicates, what its local LAN API can do, and which tools will get you building fastest.
The official Times Gate setup walkthrough from Divoom's YouTube channel.
How the Times Gate Talks to Your Network
Before you write a single line of code, you need to understand one thing that trips up almost every developer the first time: the Times Gate does not expose a local API the moment you power it on. When the device boots, it reaches out to Divoom's cloud servers using MQTT for real-time messaging and HTTPS for data synchronization. Only after that initial cloud handshake completes does the local HTTP endpoint become available on your network.
This is a different architecture from the Pixoo-64, which operates as a simpler local device. If you have used the Pixoo-64's REST API before (covered in our Pixoo-64 API beginner guide), expect a steeper learning curve with the Times Gate. The cloud dependency means you need a working Wi-Fi connection with internet access during setup, and the local API will disappear if the device loses its cloud link.
Why does this matter? Because it shapes every decision you make about how to control the device. If you are building a smart home dashboard that needs to survive an internet outage, you will need a fallback strategy. If you are just running scripts from your desk, the cloud handshake is a one-time setup step and the local API works smoothly afterward.
The Times Gate is not a single-screen device with an API bolted on. It is a five-screen dashboard that happens to be fully programmable — once you understand how to talk to it.
The Local LAN API: What You Can Control Directly
Once the Times Gate is connected to your Wi-Fi and has completed its cloud handshake, it exposes an HTTP API on your local network. Community developers have mapped out the main capabilities through experimentation and reverse engineering. Here is what you can actually do with that endpoint:
- Switch screen channels — tell each of the five screens to display a different channel (clock, weather, stock ticker, social stats, custom art).
- Push custom pixel art — send raw pixel data to a specific screen, which means you can render anything that fits in a 128×128 grid.
- Control brightness and volume — adjust the display intensity and audio output programmatically.
- Query device status — read the current state of each screen, active channels, and connection info.
The API communicates over standard HTTP, which means you can hit it from any language that can make a network request — Python, JavaScript, Rust, Go, even a shell script with curl. There is no authentication token or API key required for local requests; the device trusts anything on the same local network.
One developer in the Divoom community on Reddit asked the same question many new Times Gate owners have: "I'm interested in controlling it programmatically instead of just using the mobile app. Does anyone know if there's an API?" The thread revealed that the local API, while completely undocumented by Divoom, is very much alive and responsive.
Setup tip
Before you start writing API calls, make sure the Times Gate is on the same Wi-Fi network as your development machine and has fully booted (the screens should show live data, not a loading state). If the local API endpoint is not responding, restart the device and verify it has internet access.
Pushing Custom Widgets to Five Screens
This is where the Times Gate gets interesting. Unlike a single-screen pixel display, you have five independent 128×128 grids to work with. That means you can build a real desktop dashboard: live stock prices on screen one, crypto charts on screen two, a weather widget on screen three, your YouTube subscriber count on screen four, and a custom pixel art animation on screen five.
The process for pushing custom content follows the same pattern regardless of which screen you target. You render your data into a 128×128 pixel bitmap, encode it in the format the API expects (typically raw RGB or a compressed variant), and send it as an HTTP POST to the local endpoint with the screen index specified. The device handles the display refresh immediately.
For practical implementations, most developers render their data server-side using a lightweight graphics library — Python's Pillow is a common choice — and then push the resulting bitmap to the Times Gate on a timer. A simple Python script that fetches stock prices from a free API, renders them as text and a mini chart on a 128×128 canvas, and pushes the result to screen one every 60 seconds is a project you can build in an afternoon.
The dual-edge ambient lighting with 12 customizable RGB effects is also addressable through the API, though community support for controlling the lighting programmatically is still maturing compared to the screen control endpoints.
Community Tools for Times Gate Development
You do not have to build everything from scratch. The developer community around Divoom devices has produced several libraries and tools that wrap the raw HTTP API into something more ergonomic. If you have used the Pixoo-64 API before, some of these tools will look familiar — several were originally built for the Pixoo and later extended to support Times Gate endpoints.
| Tool | Language | What it does | Best for |
|---|---|---|---|
| pixoo-rest | Python (REST server) | Runs a local REST server that wraps Divoom HTTP APIs; supports drawing pixels, lines, rectangles, text, and auto-downloading images | Developers who want a REST middleware layer between their app and the device |
| divoom-cli | Rust | Command-line tool and library; includes LAN device discovery, channel switching, and raw pixel pushing | Rust developers and anyone who prefers CLI scripting over writing a server |
| Divoom.Api | C# / .NET | .NET library wrapping Divoom device APIs; originally built for Timebox devices | C# developers in the .NET ecosystem |
| divoom-gateway | REST gateway (Swagger UI) | Standalone REST API gateway with OpenAPI spec and Swagger UI; wraps raw Divoom HTTP APIs for any language | Teams who want a documented, language-agnostic API layer with built-in exploration UI |
Each tool takes a different approach. Pixoo-rest is the most popular starting point for Python developers because it handles the protocol details and gives you clean endpoints like /api/draw/text or /api/draw/rectangle. The Rust-based divoom-cli is excellent if you want a compiled binary you can call from shell scripts or cron jobs. Divoom.Api covers the .NET side. And divoom-gateway is the right choice if you are building something multi-language and want Swagger documentation out of the box.
The Rust ecosystem deserves a special mention because the pixoo-rest project and the Rust divoom crate both include a device discovery API — you call one function and it finds every Divoom device on your LAN. That is genuinely useful when you have multiple displays or when the device's IP address changes after a router reboot.
Home Assistant Integration
If you run Home Assistant, you do not need to write a custom application to control the Times Gate. The local HTTP API is directly accessible via Home Assistant's REST command integration, which means you can send API calls as part of any automation.
The setup is straightforward. You define a REST command in your configuration.yaml that points to the Times Gate's local IP address and the API endpoint you want to call. Then you trigger that command from any automation — a button press, a time trigger, a state change on another sensor, or a voice command. The Home Assistant community discussion around Divoom devices includes working examples of REST command configurations that switch screen channels, push custom images, and adjust brightness based on ambient light sensors.
Practical automation ideas that Times Gate owners have built with Home Assistant include switching all five screens to a "focus mode" clock when a Pomodoro timer starts, displaying weather alerts when a storm warning triggers, showing a doorbell notification with a custom pixel animation when someone rings, and cycling through social media stats every few minutes during a livestream.
One thing to keep in mind: because the Times Gate needs its initial cloud connection before the local API is available, you should add a condition to your Home Assistant automation that checks whether the device is responsive before sending commands. A simple ping check prevents error logs from piling up if your internet drops.
What the API Can't Do Yet
Being honest about limitations is part of being a good developer guide. The Times Gate's community API is powerful, but it has real constraints you should know about before you build a production system around it.
First, there is no official API documentation. Everything the community knows comes from reverse engineering, which means the API could change with a firmware update without notice. If you build something critical on top of the local API, have a fallback plan — even if that fallback is just checking whether your scripts still work after each firmware update.
Second, the cloud dependency is a hard requirement. One user in the Home Assistant subreddit discovered this the hard way when they tried to run their Divoom device in an isolated VLAN without internet access. The REST API simply did not respond until they allowed the device to reach Divoom's cloud servers first. If you are planning a fully air-gapped smart home setup, the Times Gate may not be the right display for that environment.
Third, community tool coverage for the Times Gate specifically is still growing. Many libraries were originally written for the Pixoo-64 or the Timebox and have been extended to support Times Gate endpoints, but not every feature has been verified on all device models. If you are using a library that was not originally designed for the Times Gate, test each API call individually before relying on it.
Firmware update safety
After any Times Gate firmware update, run a quick test of your API scripts before assuming everything still works. Pin your firmware version if you have a stable automation pipeline that you cannot afford to break.
FAQ
Does the Times Gate have an official API?
No. Divoom has not published an official API document for the Times Gate. However, the developer community has reverse-engineered the local HTTP API and built libraries in Python, Rust, and C# that make it practical to control the device programmatically.
Can I control the Times Gate without an internet connection?
Not fully. The Times Gate requires an initial cloud connection via MQTT and HTTPS before its local LAN API becomes available. Once that handshake completes, local API calls work without ongoing internet access — but if the device reboots or loses power, it will need to reconnect to Divoom's cloud servers before the local API responds again.
What programming languages have community libraries?
Python (pixoo-rest), Rust (divoom-cli and the divoom crate), and C# (Divoom.Api for .NET). There is also divoom-gateway, a standalone REST API gateway with Swagger UI that works with any language capable of making HTTP requests.
Does Home Assistant support the Times Gate?
Yes, through Home Assistant's REST command integration. You define a REST command pointing to the Times Gate's local API endpoint and trigger it from any automation. The Home Assistant community has working examples for Divoom device integration.
Can I push custom widgets to individual screens?
Yes. Each of the five 128×128 LCD screens can display independent content. You can push custom pixel art, text, or rendered data to any specific screen by addressing it through the API's screen index parameter.
Where to Go from Here
If you already have a Times Gate, start by running a simple curl command against the local API to switch a screen channel — that is your "hello world" moment. From there, pick the community tool that matches your preferred language and build a small project: a stock ticker, a weather dashboard, or a custom notification animation. The Times Gate rewards experimentation, and once you have one screen doing something custom, the other four follow naturally.
If you are coming from the Pixoo-64 world, our Pixoo-64 API beginner guide covers the simpler local REST API model that the Pixoo uses — useful context for understanding what changed with the Times Gate's cloud-connected architecture. For hardware setup and official product documentation, the Divoom product manual page has the current guides.
Divoom Times Gate
Five independent 128×128 LCD screens, Wi-Fi connected, fully programmable through local API and community tools. Built-in widgets for stocks, crypto, weather, and social stats.
View Times Gate
