Quick Answer: Garage door monitoring without myQ means wiring a local controller, such as the ratgdo32 board, to your opener's wall-panel terminals. The board talks to the opener over your home network using LiftMaster's Security+ 2.0 protocol, so you can get open and close state from HomeKit, a local web page, or a script. Nothing depends on a cloud service.

Garage door monitoring has a trust problem. Most alerts are only as good as the server behind them, and when that server changes its rules, your automations quietly stop meaning what you think. Chamberlain cut off third-party access to its myQ APIs in late 2023, and a Hacker News write-up by Harrison Page describes what happened next: ad-heavy app notifications that the author could no longer rely on. The fix wasn't a better app. It was taking the signal back onto the local network.

Why Cloud Garage Alerts Lose Their Value

The myQ app worked, mostly. Notifications arrived, and for a while the author trusted them because a door opening while you're away is exactly the event you want to know about. The problem is that a notification you can't trust is worse than none, because it trains you to ignore the next one.

This is the failure mode most people never notice. Cloud-dependent alerts can break for reasons you can't see: an API deprecation, a changed account policy, an app update that buries the event under promotions. When the signal goes stale, you don't get an error. You get silence that looks like safety.

Here's the part most guides skip. The popular advice is to add more alerts, one for every open, close, and motion event. In practice, that creates noise. The more useful design is state-based: check whether the door is open at a specific time, and alert only when that state is wrong. The rest of this guide follows that logic.

What the ratgdo32 Board Actually Does

The ratgdo32 is a Wi-Fi control board, sold by ratcloud LLC for roughly $62 according to the source, that runs open-source firmware. It wires into the existing terminals on your garage door opener, and it speaks the opener's own protocol locally. That protocol is LiftMaster's Security+ 2.0, which the board implements without a cloud relay.

The firmware exposes the door through two channels that matter for monitoring. The first is native integration with Apple HomeKit, which is how the author controls the door with voice commands such as "Hey Siri, open Door 1." The second is a built-in web interface and a JSON status endpoint. That endpoint is the important one for automation, because a script can read door state without parsing a UI or trusting a vendor's app.

The install itself is manageable, but treat it as real electrical work. Disconnect power to the opener before touching terminals, follow the board maker's wiring diagram for your model, and confirm your opener is compatible before you buy. Not every opener uses the same protocol, and a board that doesn't match your hardware will simply not work.

Give Each Board a Fixed Address

Before you write any monitoring code, reserve a static address for each board. The author's router hands each device a fixed address, 192.168.0.192 and 192.168.0.245, and that's the approach you want. Use a DHCP reservation tied to the board's MAC address rather than a manually configured static IP, since reservations are easier to audit and don't collide with the router's pool.

The reason this matters is a failure mode you'll hit eventually. If a board's address changes, your poller keeps hitting the old IP, gets a timeout, and reports nothing useful. The script doesn't crash, so you may not notice for days. Pinning the address turns a silent failure into a predictable one.

Rebuilding the Mercury Switch in Software

The most interesting part of the author's setup isn't the hardware. It's the reasoning behind it. The author's father wired a mercury switch to the family garage door so that a hallway light came on when the door was left open. That light was a state indicator, and it prevented the overnight open-door problem that a lot of households quietly live with.

The software version works the same way. A cron job polls the JSON status endpoint every 10 minutes during overnight hours and posts to Slack only when the door is open. The author's script is called garage-watch, and the maintainer accepted a small pull request to the project, which is a useful reminder that these tools are often built by one person solving one annoying problem.

Here's where the design earns its keep. A naive version alerts on every poll while the door stays open, which means one alert every ten minutes all night. That's the same noise problem as before. The fix is to store the last-alerted state and send a single notification per open event, then a reminder only if the door stays open past a threshold you choose. That's the difference between a useful alarm and one you mute.

The overnight window also has a practical reason. Checking state only during hours when the door should be closed keeps you from getting pinged for a normal morning departure. Pick your window based on your own routine, not a default.

Remote Access Without Opening Ports

Local control is great until you're away and want to check the door. The author uses Tailscale, a WireGuard-based mesh VPN, to make both boards reachable from outside the house. The mechanism is a subnet router: one device on your home network advertises the board addresses to your tailnet, so your monitoring software can reach them without any port forwarding.

The setup has two steps that people miss. First, you advertise the routes with the tailscale set --advertise-routes command, listing each board as a /32 address. Second, you approve those routes in the Tailscale admin console. Until you approve them, the routes exist on paper but traffic doesn't flow, and your health check fails in a way that looks like a hardware problem.

Once the routes are live, your monitoring tool can load the board's /healthcheck endpoint. That gives you a second signal: not just "the door is closed," but "the board that reports the door is alive and reachable." Monitor both. A closed-door reading from a dead board is not the same as a verified closed door.

There's a real caveat here. Advertising a subnet puts every device on that subnet within reach of anyone who can reach your tailnet, so use Tailscale access controls to limit which devices can see the garage boards. Don't expose the board's web interface directly to the internet, and keep the firmware updated.

Choosing Between Your Options

The right approach depends on what you're trying to protect and how much you're willing to build. The table below compares the main routes people take.

ApproachData pathTells you who opened the door?Main trade-off
myQ app (Chamberlain cloud)Vendor cloud, then app pushNo, shows generic open/close eventsDepends on vendor APIs and policy; ads in the app
ratgdo32 with HomeKitLocal Wi-Fi, Apple HomeVia Home automations and device namesRequires install work; HomeKit-specific ecosystem
ratgdo32 with JSON polling and SlackLocal network, custom scriptYes, if your script logs the trigger sourceYou maintain the script and its failure modes
Standalone magnetic contact sensorZigbee or Z-Wave to a hubOnly that a door changed stateNo opener control, and extra hub required

The table shows a real trade-off, not a winner. A magnetic contact sensor is the simplest way to know if a door is open, but it can't tell you whether the opener responded to a command, and it can't open the door for you. The ratgdo route gives you control and state, at the cost of more setup and more maintenance.

Here's the nuance: "who opened the door" is only as accurate as the trigger your system receives. A HomeKit automation can label a voice command, but it can't know if someone pressed a wall button. If accountability matters, log the source your controller reports and accept that some events won't be attributable.

Know the Limits Before You Trust It

No local setup is risk-free. Firmware bugs can break compatibility with your opener, and a bad wiring job can damage the board or the opener's control circuit. Warranty terms may change if you modify the hardware, so check your opener's documentation first. Local control also doesn't protect you from a failing Wi-Fi network, so a router reboot can silence your alerts.

The counter-intuitive lesson is that you should test failure, not just success. Close the door, open it, reboot the router, and confirm your alert still fires. Then unplug one board and confirm your health check catches it. A monitoring system you haven't tested is a hope, not a system.

Frequently Asked Questions

How do I set up garage door monitoring without myQ?

Disconnect the opener's power, wire a local controller such as the ratgdo32 to the opener's control terminals, and confirm the board matches your opener's protocol. Reserve a fixed address on your router, connect the board to HomeKit or its JSON status endpoint, then write a poller that alerts on the state you care about. Test the full chain before relying on it.

What is the ratgdo32?

The ratgdo32 is a Wi-Fi control board made by ratcloud LLC that connects to a garage door opener's terminals. It runs open-source firmware and speaks LiftMaster's Security+ 2.0 protocol over your local network. It exposes the door to HomeKit and a JSON status endpoint, so you can monitor or control the door without the vendor's cloud service.

When should I get a garage door open alert?

Alert on the state that's wrong, not on every event. A common approach is to check during overnight hours, send one notification when the door opens, and send a reminder only if it stays open past a threshold you set. That avoids a stream of duplicate messages and keeps the alert useful enough that you act on it.

How can I check if my garage door is open remotely?

You can reach a local controller through a mesh VPN like Tailscale, using a subnet router to advertise the board's address to your tailnet. After you approve the route, your monitoring tool can read the board's status and health endpoints. Restrict access with Tailscale's access controls and never expose the board's web interface to the public internet.

Start Small and Test It This Week

The lesson from this setup is that garage door monitoring works best when you own the signal, not the app. Pick one board, pin its address, and build one alert that fires only when the door is open at a time that matters to you. Then close the door, break the network on purpose, and see what your system does. Pass this to anyone who still trusts a cloud notification to tell them the door is closed, and ask them to run the same test.