Most “AI cameras” you can actually buy today are just IP cameras with a thin cloud API bolted on top, sending your data off to an unknown cloud server somewhere. The heavy lifting still happens on said server, which is bad news if you care about latency, bandwidth, or sending raw video off-site for every little thing. That’s why the CamThink NE301 is unique, as it goes in the opposite direction entirely and shifts that processing to a local-first model, complete with a ton of extra features, too.
To be precise, this is a tiny, IP67-rated box powered by batteries, USB-C, or Power over Ethernet, and it’s built around the STM32N6 microcontroller, complete with a built-in NPU that can run You Only Look Once (YOLO) models locally at up to 25 frames per second. And that’s just a single board, a 4MP sensor, and a decent web-interface. If you’ve ever wanted a real edge-AI camera that you can mount outside, power with batteries or PoE, and to point it at a problem without writing bare-metal firmware, then this is the perfect device for it.
Camthink NE301
The Camthink NE301 is a local-first camera that you can set up and deploy anywhere, powered by PoE, USB-C, or four AA batteries. It supports MQTT and can run local YOLOv8 vision models, powered by an STM32N6 and an integrated NPU.
The CamThink NE301 has impressive hardware
And well documented software, too
No matter what way you look at it, this is a pretty interesting piece of tech. At a high level, the NE301 is a self-contained edge AI camera, but the hardware details are pretty impressive, too. The STM32N6 at the heart of it all packs an Arm Cortex-M55 CPU and a Neural-ART NPU rated at around 0.6 TOPS, running at up to 1 GHz. That’s paired with 4.2MB of on-chip SRAM, 64MB of PSRAM, and 128MB of HyperFlash, plus a microSD slot for local storage. Meanwhile, On the outside, it looks like a chunky little industrial camera in an IP67-rated enclosure, with a tempered glass front panel, and mounting points on the back.
By default it ships with a 4MP MIPI-CSI sensor, but you can swap in USB camera modules and different lenses for narrow, wide, or ultra-wide fields of view depending on where you’re mounting it. It’s still “just” a microcontroller system, but the NPU and codec block mean it can handle H.264 or JPEG encoded 1080p30 video and run lightweight detection models on the stream in real time. Plus, there’s a 16-pin expansion header that breaks out UART, RS-485, I2C, SPI, and GPIO lines, plus selectable 3.3V and 5V rails.
Out of the box, the NE301 spins up its own Wi-Fi access point, where you can then configure it, including connecting it to your actual network. From this web UI, you can see a live video preview, switch between different models, upload your own YOLOv8 models, and adjust thresholds and output formats.
CamThink’s own docs and community posts lean heavily on YOLOv8: the NE301 is positioned as an “AI-deployable” STM32N6 camera, with a graphical interface specifically aimed at getting YOLO models onto the device without needing to touch low-level embedded code. In practice, this means you can treat it almost like a headless IP camera that happens to have a model management page built in. Train a model on your PC, export it in a supported format, then upload it through the browser.
To build for the Camthink NE301, you’ll need to set up their custom environment, or deploy their Docker container. Thankfully, it’s not difficult, and the only essential dependency I needed to install to set up the local environement was pnpm. Through either method, you can then build your own firmware and make changes to the operating system, or you can just build your own YOLO-based models, trained on your computer, and deploy them as well.
The full development and model training pipeline is provided by Camthink, so that you can easily get up and running quickly.
It feels like a full-fledged product
Not just a devboard
The Camthink NE301 feels surprisingly polished, and a large part of that comes down to its web UI. Out of the box, it can spin up its own Wi-Fi access point and serve a browser-based UI, offering the following:
- Live video preview with detection overlays
- Switch model parameters
- Upload your own models
- Adjust event triggers and connectivity
If you wanted to buy this as a finished product to detect objects and movements, sending everything over MQTT, then you have everything you need out of the box. Every aspect of the software is ready to go, and it doesn’t feel like anything has been ignored or left over. If you want to expand it and add your own features, you definitely can, and you can add your own hardware, too.
The hardware itself is geared towards YOLOv8 models running at about 25 FPS, though that’s obviously dependent on model size and resolution. Still, it’s good enough for things like person detection, movement detection, zone alerts, and more. Plus, it all happens on device, so instead of streaming raw video back to a server for processing, you can just push the results to a server instead.
If you want something more custom, like recognising specific equipment states, non-standard tools, or your own IoT widgets, you can train a model, export it, and run that instead. You’re still working within microcontroller-class constraints, so you’re not going to deploy a giant vision transformer or anything like that, but for compact detectors, the NPU has more headroom than you might expect.
The NE301’s low-power-first model combined with modular sensing capabilities and the ability to send detections rather than video streams are all what makes this particular camera appealing. If you’re already playing with STM32, MQTT, or low-power IoT gear, this slots neatly into that world. And if you’ve been looking for a way to deploy your own custom vision models and into places that don’t have mains power or fast internet, it’s exactly the kind of device that makes those experiments feel a lot more realistic. I’m excited for where development around the Camthink NE301 goes, and I’m sure I’ll find some unique ways to put it to use.
Leave a comment