Android
Native Kotlin app with a Compose UI.
- Camera frames reach the encoder with no copy to storage
- Hardware H.264 when the phone has it, software encoding when it does not
- Detection on the CPU, so mid-range phones work too
Edge AI video intelligence
Any phone.
A monitored camera.
AIPlayerX streams live video from any device to any screen over WebRTC, and runs object detection where the frame is captured — so footage never has to leave the camera to become useful.
Android · iOS · Web — one native core, one signaling hub.
room / living-room
Connected
H.264 hardware encoded
Peer to peer · low latency
On-device detection
- 2
- native apps on one shared media core
- 6 s
- of footage kept before every trigger
- 90 → 10
- classes the detector sees, ten of which raise an event
- 0
- frames uploaded to run detection
Cross-platform by construction
One pipeline, from a phone in a room to a browser anywhere.
Capture, encode, signal and render all live in one shared native core, used unchanged by both apps. Platform code owns the camera; the core owns the stream.
iOS
Swift app on the same shared viewer and sender.
- Hardware H.264 through the system video pipeline
- The same detector as Android — same file, same behaviour
- iOS 16 and up
Web
Zero-install viewer for anyone with a browser.
- WebRTC playback, plus a fallback stream when a direct connection cannot be made
- Auto-tiling by source aspect ratio, 0° or 90°
- Per-tile play, mute, rotate and reconnect
- Detection feed in a side panel
The relay
Accounts, signalling, and a relay for the cases where direct fails.
- Accounts, sessions and device list
- Passes signaling messages between peers
- Keeps no video — it is not a recorder
- Only in the media path when a direct connection is impossible
Desktop builds for macOS and Windows are in progress; Android, iOS and the web viewer are generally available today.
What it does
Six things that make a phone behave like a camera you would actually buy.
WebRTC that starts in seconds
A cheap Android phone and a browser can talk to each other without anyone configuring a codec or a network path. The negotiation quirks between platforms are handled inside the app, and when a direct connection cannot be established the viewer drops to a lower-quality stream instead of showing a black tile.
Detection on the frame, not in the cloud
Detection runs on the phone that captured the frame, and it is deliberately slower than the video. A still room is re-checked about once a second; a busy one no more than every two. Only one look is ever in flight, so a slow round delays the next look rather than building a backlog the encoder has to compete with.
Clips that start before the event
Encoding runs continuously into a six-second pre-roll. When a scored object crosses the threshold, the clip is cut from footage you already have — six seconds before the trigger, six after — and trimmed back to a keyframe so the file plays from its first frame.
Events, not 400 notifications
Temporal correlation groups frames into events inside a five-minute window, deduplicates at thirty seconds, and a rule chain ranks each event from Emergency down to Low. You get a timeline and a daily summary, not a firehose.
One sender, many viewers
Each sender owns a SignalR room. Anyone with the link and a valid session joins the same stream — a phone on the wall, a laptop in another city, a browser on a tablet — without re-encoding per viewer.
A pipeline you can debug
States are explicit: Idle, Starting, Running, Stopping, Failed. Startup only counts as success when the connection is up and the first frame has actually been decoded — not when the app merely asked the camera to start.
Detection
A small model, run honestly on the device that captured the frame.
No GPU cluster, no per-frame billing, no frame leaving the phone. The detector scores every frame it is given, and a short allow-list decides which of those scores is worth waking you for.
Where it runs
On the phone
inside the app
The detector is part of the app download, not a service. Nothing is fetched at run time, so it works on a phone with no data connection at all.
- Works with no network connection
- The same detector on iOS and Android
- Picked to run on mid-range hardware, not flagships
- No account, no key, no quota
What triggers 10 classes
90 → 10
The network scores all 90 of the classes it was trained on. Only ten of them raise an event, and the filter is applied after scoring, so both apps cut clips for the same scene.
- person
- cat, dog, bird
- car, truck, motorcycle
- backpack, handbag, suitcase
What it costs you Nothing extra
$0
No per-frame fee and no cloud GPU. Inference is deliberately slower than the video — about one round a second — because it has to share the phone with the encoder.
- Detection yields to the encoder — video stays smooth
- One look in flight at a time, never a backlog
- Recovers on its own after repeated failures
- Skips a look under memory pressure, never the stream
Reading a clip back as a sentence, and a heavier cloud model for sites that want one, are on the roadmap — not available today.
How it works
Four hops from a lens to an event.
-
1
Capture
The camera delivers raw frames. The platform layer owns permissions and lifecycle; nothing else touches the camera.
Camera → encoder -
2
Encode & stream
Hardware H.264 where the device has it, checked at runtime; software encoding where it does not. Negotiation with the viewer is handled for you.
Encoder → WebRTC -
3
Detect & aggregate
Sampled frames are scored, land in the clip pre-roll, and roll up into events with a priority and a video attached.
1 look / second -
4
Watch & review
Viewers join the room and play. Each event arrives with its clip, its priority and the label that fired — then rolls up into the day and month views.
room:living-room
Privacy and control
Detection never needs your footage to leave the building.
The default path keeps inference on the phone. What crosses the network is a video stream you asked for and the signaling needed to start it — nothing else.
- On-device inference. Detection runs against a model shipped inside the app. No frame is uploaded to find an object.
- Tokens in the platform keystore. Session and refresh tokens live in the operating system's own secure store, never in a cookie you cannot see.
- Signalling relays; nothing records. It passes the handful of messages two devices need in order to find each other, and when it has to carry the video itself no byte is written to disk.
- Least-privilege server. The service that relays those messages cannot write to the database at all; only the accounts service can.
Pricing
Free to download.
A dollar a month to go live.
Detection runs on your own phone, so it costs us nothing and it is free. Going live needs our servers, and that is what the subscription pays for. Try it before you pay: 90 minutes of live streaming, valid for seven days.
Free
$0
to download, no card needed
- One account, on Android and iOS
- Pair your devices and watch the live preview
- On-device detection on the sending phone
- 90 minutes of live streaming to try, usable for 7 days
- Everyone you invite can watch, free
Live
$0.99
per month, cancel any time
- Go live with no time limit
- Everything in Free stays — nothing is taken away
- One subscription covers both platforms on the same account
- Cancel from Google Play or the App Store whenever you like
- Direct email support
Prices in USD; your app store shows the local equivalent. Renews automatically until cancelled. Subscription terms · Volume or procurement question? Talk to us.
Questions
The things people ask in the first call.
Does my video go through your cloud?
Only when it has to be. Video normally travels peer to peer over WebRTC, on your own network. When a direct route is impossible — symmetric NAT, a firewall that blocks the media path — it is relayed through our server for that session, and nothing is written to disk. Detection always runs on the phone that captured the frame.
What if the WebRTC connection fails?
The viewer falls back to an MJPEG stream served from the sender, throttled to roughly 10 fps. It is lower quality by design, but a tile that shows something beats a tile that shows black.
Which devices can act as a camera?
Any Android phone on 8.0 or newer, and any iPhone on iOS 16 or newer. There is no dedicated hardware to buy: a device runs the sender once and keeps streaming for as long as it stays on the monitoring screen.
How many people can watch at the same time?
There is no per-viewer limit or charge. Viewers join a signaling room; the sender encodes once and the media path is negotiated per peer. Practical limits come from the sender's uplink, not from our licensing.
Can I run it on my own hardware?
Not today. The server is two containers we operate, and the apps talk to our endpoints. There is no bring-your-own-server option yet. If that is a blocker for you, tell us before you buy rather than after.
Is there an open API?
No. There is no public API or integration programme today — the mobile apps and the web viewer are the only clients. If you need to drive it from your own systems, talk to us before you commit.
Which model does it run?
EfficientDet-Lite0, float32, 13.8 MB, shipped inside the app — the same file on iOS and Android, checksum-pinned so the two cannot quietly drift apart. MediaPipe Tasks Vision is the runtime: CPU by default, GPU delegate opt-in on Android. The score threshold is 0.40 and three results are kept per frame.
Point a phone at the room. See it in a browser in under a minute.
We will set up a demo room on your devices and walk you through the pipeline, the detection thresholds and where the data actually goes.