Hi All !
i have seen multiples subjects but often not answered or not continued on this specific case.
I have two Aosu cameras:
Camera Aosu
And i have tried multiple things to integrate them in HA :
Nothing works , i can’t find a real answer if there any other solution even complex to put in place to have them in Home Assistant or if there is really no possibility to this date ?
Thanks in advance for any help !
Can you provide a link to the documentation that assisted you in trying these things? How for instance did you turn on ONVIF support - which is probably the simplest way to integrate camera into HA.
Is there an API for alarms? User forums that discuss integrating these with anything but the supplied app?
They look like a fairly capable camera, but documentation apart from “quick start guides” seems to be non-existant on their website.
Hi !
There is no documentation assisting me to do theses tests , i have made research on internet and trying to integrate them , but they seems to have no RSTP flow available exept the flow in their App Aosu …
ONVIF not working neither …
I can’t find any API for theses cameras , yes user forum can’t seems to find any solutions.
If cameras support RTSP or ONVIF, they will mostly work out of the box.
Or else, someone has to find the streaming logic and bring it to open source world, then it can be integrated to home assistant or scrypted. If it is already working with scrypted, you can expose them to home assistant.
All other questions go to camera producer.
On my cameras ONVIF is turned off by default, the setting to turn it on is buried under “Network - Advanced” on a page of its own.
Have you found any settings in your camera to turn on ONVIF?
I came across your question here as I too was just looking to do similar integration with a couple of AOSU solar cams I have. After no success researching briefly on my own, I asked chatgpt. Here is the response, maybe will give you some ideas or lead to someone far smarter than I figuring out the traffic infrastructure and enabling something useful. I am going to try the input booleen thru Alexa with associated routines.
Short version: your HL1-based AOSU solar kit is a locked, cloud-centric system. There is no published local API, no RTSP, no ONVIF, and no existing Home Assistant integration as of now. Getting anything beyond basic motion triggers into HA will require real hacking, not just clever configuration.
Let’s walk the landscape and then I’ll lay out realistic options.
From AOSU’s own material and community posts:
Cameras pair to a Home Station / HomeCortex hub (your HL1) which:
Stores video locally (e.g. 8–32 GB loop recording)
Connects to your router via Wi-Fi.
Talks to AOSU’s cloud APIs (domains like api-us.aosulife.com, api-eu.aosulife.com) used by the mobile app.
Official “third-party” support is Alexa and Google Assistant only. AOSU’s own community explicitly describes integration only in terms of linking the camera to Google Home / Alexa—not any generic API or local control.
Their support forum + HA threads indicate:
No RTSP stream exposed except what the AOSU app uses internally.
ONVIF doesn’t work (no endpoint, no toggle in settings).
So architecturally you’ve got:
Camera (proprietary wireless) → HL1/HomeCortex → AOSU Cloud → Phone App / Alexa / Google
No friendly local NVR / DVR interface, no documented LAN API.
Home Assistant discussions
Multiple HA threads (“Aosu cameras”, “Aosu cameras and doorbell integration”) have people trying:
Scrypted
Agent DVR / iSpy
ONVIF
Android emulation
…and none of it sticks, because there’s no RTSP/ONVIF to latch onto.
In at least one thread, the person literally gave up and swapped the cameras for Reolink to get native HA support.
GitHub / developer side
There is no AOSU HL1 or HomeCortex integration repo for Home Assistant or Scrypted that I can find.
There is a firmware-hacking project, Thingino, with an installer for an AOSU C5L standalone IP cam (no hub):
That project is for Ingenic-based IP cams where you can boot off SD and flash open firmware.
It does not mention hub-based solar systems / HL1 or HomeCortex.
AOSU’s own “community” and marketing material are all about the app + cloud, plus their Alexa/Google integrations; there’s no public device API.
Net: as of late 2025, there is no maintained, plug-and-play HA integration for HL1-based AOSU systems.
Given that, your choices fall into five buckets, from “least painful” to “full gremlin mode”.
Option A – Event-only integration via Alexa + Home Assistant
You already live in HA and Alexa land, so this is the most pragmatic first move:
Idea:
Use Alexa’s AOSU integration to detect motion / doorbell events, and then have Alexa flip virtual devices that HA can see.
High-level steps:
In HA, create an input_boolean for each camera event you care about:
input_boolean:
aosu_front_motion:
name: AOSU Front Motion
aosu_driveway_motion:
name: AOSU Driveway Motion
Expose these via the official Alexa integration (or Nabu Casa if you use it). They’ll show up in Alexa as smart switches.
In the Alexa app:
“When: [AOSU Front Camera] detects motion → Action: Turn on [AOSU Front Motion] switch.”
Optionally add an action to turn the switch back off after X seconds using another routine or a simple HA automation.
Now you can do things like:
automation:
Pros
Works today, no hacking firmware.
You get motion / doorbell events inside HA for automations.
Cons
No video stream inside HA.
Dependent on Alexa and AOSU clouds working.
Latency may be noticeable (1–3 seconds, typically).
Still, this at least lets your existing cameras participate in your HA brain.
Option B – Try to discover any hidden local stream (low probability, low effort)
Even though forum posts say “no RTSP/ONVIF”, it costs you very little to double-check:
Find HL1’s IP from your router / DHCP.
Port scan it from a laptop:
nmap -sV -p 1-65535 <HL1_IP>
554/tcp open rtsp
80/tcp open http with camera-looking endpoints …try pointing VLC or HA’s generic camera integration at:
rtsp://<HL1_IP>:554/…
http://<HL1_IP>/live or /stream etc.
Given user reports (“no RTSP flow available except in their app”, “ONVIF not working”), expectations are low, but if you got lucky on a specific firmware revision, this would immediately unlock Frigate + HA.
Option C – Cloud API reverse-engineering + custom HA integration (deep-dive project)
This is the “I want a winter project” path.
We know the app talks to domains like api-us.aosulife.com for account verification and presumably everything else.
Theory of operation:
Use mitmproxy or Charles Proxy with an Android emulator or a spare Android phone.
Install your custom CA cert so you can decrypt TLS (assuming they don’t use strict certificate pinning; if they do, game becomes much harder).
Log calls while you:
Open the live view,
Trigger motion,
Review recordings, etc.
Identify endpoints for:
Authentication / token refresh.
Device list (cameras, hub).
Event notifications (motion, doorbell, offline, etc.).
Snapshot or cloud live-view URLs (if any are HTTP(S) and not some proprietary tunneled protocol).
Document methods, payloads, and auth headers.
Using aiohttp, wrap those endpoints into a clean async API:
class AosuClient:
async def async_login(self, username, password): …
async def async_get_devices(self): …
async def async_get_snapshot(self, device_id): …
async def async_list_events(self, device_id): …
This becomes your core for both testing and the HA integration.
Under custom_components/aosu/:
init.py – set up the client, handle config & token refresh.
manifest.json – basic integration metadata.
camera.py – expose each AOSU camera as a camera entity, using snapshots or proxied MJPEG/WebRTC if possible.
binary_sensor.py – expose motion / doorbell events as binary sensors.
If snapshots are accessible over HTTPS, HA’s GenericCamera or your own camera platform can pull stills periodically; if you can get a streaming URL, even better.
Start with YAML config or a simple config_flow for UI setup.
Test with just:
“List devices”
“Grab snapshot every 10 seconds”
“Poll events every X seconds and flip motion sensors.”
Huge caveats:
ToS / legal: Reverse-engineering cloud APIs may violate terms of service. You’d want to read their ToS and be comfortable with the risk.
Security: You’re handling cloud credentials in your own code; you must treat that integration like any other cloud login.
Fragility: They can change their API at any time and your integration breaks.
They may use certificate pinning, which would block TLS MITM without more invasive techniques (rooting, patching the app, etc.).
This is absolutely doable for a determined tinkerer, but it’s firmly in “DIY research project” territory, not “weekend config tweak”.
Option D – Hardware / firmware hacking (Thingino-style), but…
The Thingino project you saw supports AOSU C5L, a different standalone camera, by flashing custom firmware via SD card.
For HL1-base solar systems, we don’t currently have:
Board photos / SoC identification
Confirmed Ingenic or other hack-friendly platform
Any existing installer or instructions
So to go this route you’d be looking at:
Opening up the hub/camera.
Identifying the SoC and flash.
Dumping firmware with a hardware programmer.
Porting something like Thingino or OpenIPC.
Writing your own RTSP/HTTP serving.
That’s basically “embedded Linux hobbyist with JTAG clips and lots of free time” territory. Not impossible, but realistically overkill unless you want the project for its own sake.
Option E – Plan a gradual migration to HA-native cameras
This is exactly what at least one HA user ended up doing: ditching AOSU for Reolink because “integration took 10 minutes”.
If your goal is:
Local recording,
Tight Home Assistant integration,
Good Frigate compatibility,
then systems that support RTSP and/or ONVIF out of the box (Reolink, Hikvision, Dahua, Amcrest, UniFi, etc.) will make your life dramatically easier.
Tactically you can:
Use Option A (Alexa → HA) so your existing AOSU setup isn’t wasted.
As cameras die or you expand coverage, replace with HA-friendly models.
Run Frigate + HA for the “serious” automation / NVR side, while AOSU remains a secondary system until fully retired.
Given your history of going deep but also liking things that actually work:
Port-scan the HL1.
Try obvious RTSP/HTTP endpoints once.
If nothing bites, accept that there’s no easy local stream.
This gets you motion / doorbell events in HA in an afternoon and plays nicely with your existing Alexa/HA setup.
If yes: start poking the AOSU cloud API with mitmproxy and build a tiny Python test client. I can help sketch the integration structure and glue into HA; you’d fill in the real endpoints once you’ve sniffed them.
If no: treat AOSU as a closed appliance and start planning a camera ecosystem that’s explicitly HA-friendly for future buys.
Right now, nobody in the wild has a clean HL1 Home Assistant integration. If you go the API-reversing route, you’re not following a recipe—you’re writing the first one.