Download MotionEyeOS — Free for Raspberry Pi

Yes, MotionEyeOS is 100% free to download and use. The project is released under the GNU General Public License v2 (GPLv2), which means you can download, install, modify, and redistribute it without paying a single cent. There are no premium tiers, no subscription fees, no feature gates, and no trial periods.

Here is what you get for free:

• Full OS image – The complete operating system image for your Raspberry Pi model, ready to flash
• All features unlocked – Multi-camera support, motion detection, email alerts, cloud uploads, scheduling, and every other feature are included
• Source code access – The entire codebase is publicly available on GitHub under the motioneye-project organization
• No account required – Download directly from GitHub Releases without signing up, logging in, or providing an email address

The image files range from 42 MB (Pi 1/Zero) to 62 MB (Pi 4), and you can download them as many times as you need. Unlike commercial surveillance systems like Blue Iris ($65 license) or Reolink NVR (monthly cloud fees), MotionEyeOS will never charge you for any functionality.

Yes, MotionEyeOS is safe to download and run on your Raspberry Pi. It is an open-source project with its full source code available on GitHub, meaning anyone can audit the code for security issues. The pre-built image files are hosted directly on GitHub Releases – not on third-party download mirrors or file hosting sites that might bundle adware.

Here are the key safety facts:

• 8,200+ GitHub stars – One of the most popular open-source surveillance projects, used by thousands of people worldwide
• No telemetry or data collection – MotionEyeOS does not phone home, track usage, or send data to external servers
• Local network operation – Your camera feeds stay on your local network by default. Nothing leaves your home unless you explicitly configure cloud uploads or remote access
• Verified source – Images come directly from the official GitHub repository at github.com/motioneye-project/motioneyeos

That said, there are a few security steps you should take after installation:

1. Change the default admin password immediately – The default login is username “admin” with a blank password. Anyone on your network could access your cameras if you leave this unchanged.
2. Set a separate surveillance password – This creates a viewer-only account for people who should see feeds but not change settings.
3. Avoid port forwarding – If you want remote access, use a VPN (like WireGuard or Tailscale) instead of exposing port 80 to the internet. The motionEye web interface does not use HTTPS by default.

No, MotionEyeOS does not support the Raspberry Pi 5. The last stable release (v20200606, dated June 2020) was built before the Pi 5 existed, and the project has not received updates to add Pi 5 compatibility. Flashing the existing images to a Pi 5 will not boot because the bootloader, kernel, and device tree files do not match Pi 5 hardware.

What boards does MotionEyeOS support?

• Raspberry Pi 1 Model A/B/A+/B+
• Raspberry Pi 2 Model B
• Raspberry Pi 3 Model B/B+/A+
• Raspberry Pi 4 Model B (all RAM variants)
• Raspberry Pi Zero and Zero W
• Several non-Pi boards: Banana Pi, NanoPi, Odroid, Orange Pi, Pine64, ASUS Tinker Board

If you have a Pi 5, here are your best options:

1. Install motionEye on Raspberry Pi OS – Install the standalone motionEye web application on a fresh Raspberry Pi OS installation. Run sudo pip install motioneye and you get the same web dashboard and camera management features. This works on Pi 5 because it runs on top of a full OS that already supports the hardware.
2. Use Frigate NVR – A Docker-based network video recorder with AI-powered object detection. It runs well on Pi 5 and can distinguish people, cars, and animals from generic motion.
3. Try RPi Cam Web Interface – A lighter alternative specifically designed for Raspberry Pi cameras, though it lacks multi-camera support.

MotionEyeOS (the full operating system image) has not received a new release since June 6, 2020 (version 20200606). The project is in maintenance mode – it is considered stable and functional, but no active development is happening on the OS images. There was a pre-release build dated October 26, 2020, but it was never marked as a stable release.

What does this mean in practice?

• The v20200606 images still work – Users running Pi 1 through Pi 4 report stable performance with the latest release. The software does not break over time since it runs on a self-contained read-only filesystem.
• No new board support – The Pi 5, Pi Zero 2 W, and any boards released after 2020 will not get official images.
• No security patches for the OS layer – The underlying Buildroot Linux system is frozen at 2020 versions. This matters less than it sounds since the device should only be on your local network.
• No new camera driver updates – Very new USB cameras or those requiring updated drivers may not work.

The motionEye web application is a separate project – and it does receive occasional updates. Developer Calin Crisan and community contributors have pushed patches to the motionEye frontend independently. You can install the latest motionEye on any Linux system (including Raspberry Pi OS) using pip.

MotionEyeOS is lightweight and runs on most ARM-based single-board computers. Here are the complete hardware requirements broken down by component:

Required Hardware:

• Board: Raspberry Pi 1, 2, 3, 4, Zero, or Zero W. Also supports Banana Pi M1, NanoPi Neo/Neo2, Odroid C1/C2/XU4, Orange Pi One/Zero, Pine64, and ASUS Tinker Board.
• Storage: microSD card, 4 GB minimum. Use 16 GB or larger if you plan to store motion-triggered recordings directly on the card. Class 10 or UHS-I speed rating is recommended for smooth video writing.
• Camera: At least one of these: USB webcam (must be UVC-compatible), Raspberry Pi Camera Module (CSI ribbon cable), or a network IP camera with MJPEG or RTSP output.
• Network: Ethernet cable or Wi-Fi (built into Pi 3, Pi 4, Pi Zero W). Ethernet is recommended for reliability and lower latency.
• Power Supply: 5V / 2.5A for Pi 3 and older, 5V / 3A USB-C for Pi 4. An underpowered supply causes CPU throttling, random reboots, and video stuttering.

RAM guidelines by use case:

• 256 MB (Pi Zero): One camera at 640×480, motion-triggered snapshots only
• 512 MB (Pi 1): One camera at 720p with motion detection and recording
• 1 GB (Pi 2/3): Two to three cameras at 720p, comfortable for most setups
• 2-4 GB (Pi 4): Four cameras at 720p or two at 1080p, with motion detection and cloud upload running

The OS itself uses under 100 MB of RAM thanks to its minimal Buildroot base. The rest is available for camera processing.

Installing MotionEyeOS takes about 10-15 minutes and requires no Linux knowledge. The process involves downloading an image file, flashing it to an SD card, and booting your Pi. Here is the step-by-step process:

Step 1: Download the image

Go to our download section and download the correct .img.xz file for your Pi model. Pi 4 users need the Pi 4 image, Pi 3 users need the Pi 3 image, and so on. File sizes range from 42 MB (Pi 1/Zero) to 62 MB (Pi 4).

Step 2: Extract the compressed file

• Windows: Right-click the .img.xz file and select “Extract Here” using 7-Zip
• macOS/Linux: Run xz -d motioneyeos-raspberrypi4-20200606.img.xz in a terminal

Step 3: Flash to SD card

Insert a microSD card (4 GB minimum, 16 GB+ recommended) into your computer. Open Balena Etcher or Raspberry Pi Imager, select the extracted .img file, choose your SD card, and click Flash. This takes 2-5 minutes.

Step 4: Boot the Pi

Insert the flashed SD card into your Raspberry Pi, connect an Ethernet cable and your camera, then plug in the power supply. The first boot takes about 1-2 minutes while the system auto-configures and expands the filesystem.

Step 5: Access the dashboard

Find your Pi’s IP address through your router admin page (look for a device starting with “meye-“) or a network scanner app like Fing. Open a web browser and navigate to http://<your-pi-ip>. Log in with username admin and leave the password field empty.

MotionEyeOS supports Wi-Fi on boards with built-in wireless (Pi 3, Pi 4, Pi Zero W) or with a compatible USB Wi-Fi adapter on older boards. There are two methods to configure Wi-Fi, and both must be done before or during the first boot since you need network access to reach the web interface.

Method 1: wpa_supplicant.conf file (easiest)

1. After flashing the MotionEyeOS image to your SD card, remove and re-insert the card into your computer
2. Open the boot partition (the small FAT32 partition that shows up in your file manager)
3. Create a new text file named wpa_supplicant.conf
4. Add the following content, replacing with your network details:

country=US
update_config=1
ctrl_interface=/var/run/wpa_supplicant
network={
  ssid="YourNetworkName"
  psk="YourWiFiPassword"
}

Method 2: writeimage.sh script (Linux/macOS only)

The official writeimage.sh script combines flashing and Wi-Fi configuration into one step. It writes the image to the SD card and bakes your Wi-Fi credentials directly into the filesystem. Download it from the MotionEyeOS GitHub wiki and run:

./writeimage.sh -d /dev/sdX -i motioneyeos.img -s "YourSSID" -p "YourPassword"

Important notes:

• The country code must match your location (US, GB, DE, etc.) – this sets the correct Wi-Fi regulatory domain
• Pi 1, Pi 2, and original Pi Zero do not have built-in Wi-Fi. You need a USB Wi-Fi adapter with Linux driver support (the Edimax EW-7811Un is a popular, compatible option)
• 5 GHz networks are only supported on Pi 3B+ and Pi 4

Yes, MotionEyeOS fully supports network IP cameras that provide MJPEG or RTSP video streams. You can use IP cameras alongside USB webcams and Pi Camera modules on the same system, mixing different camera types freely.

How to add a network IP camera:

1. Open the motionEye web interface in your browser
2. Click the drop-down menu in the top-left corner (next to the camera name)
3. Select “add camera”
4. Choose “Network camera” as the camera type
5. Enter the camera’s stream URL in the URL field. Common formats include:
   • RTSP: rtsp://192.168.1.100:554/stream1
   • MJPEG: http://192.168.1.100:8080/video
6. If your camera requires authentication, enter the username and password
7. Click “OK” to add the camera

Performance considerations:

• Each IP camera stream consumes CPU cycles for decoding. A Pi 3 can handle 2-3 IP cameras at 720p. A Pi 4 can handle 4-5 comfortably.
• MJPEG uses less CPU than RTSP because MJPEG frames are individual JPEGs (no inter-frame decoding needed). If your camera supports both protocols, try MJPEG first.
• Use the camera’s sub-stream (lower resolution secondary stream) if available. Many cameras offer a 640×480 sub-stream that is much lighter on the Pi’s CPU than the full 1080p main stream.
• IP cameras send data over your network, so wired Ethernet on the Pi side reduces latency compared to Wi-Fi.

Compatible camera brands: Most modern IP cameras work, including Hikvision, Dahua, Reolink, Amcrest, TP-Link Tapo, and Wyze (with RTSP firmware). Check your camera’s documentation for the exact RTSP URL format.

MotionEyeOS can send you an email with a snapshot attached whenever motion is detected on any camera. This requires configuring an SMTP email server in the web interface. Here is the complete setup process:

Step-by-step configuration:

1. Open the motionEye dashboard and click the wrench/settings icon for the camera you want to configure
2. Scroll down to the “Motion Notifications” section
3. Toggle “Send An Email” to ON
4. Fill in the SMTP settings:
   • Email Server: Your SMTP server address
   • Port: Usually 587 (TLS) or 465 (SSL)
   • Account: Your full email address
   • Password: Your email password or app-specific password
   • From Address: The sender email address
   • To Address: Where you want to receive alerts
5. Click Apply to save

Gmail-specific settings:

• Email Server: smtp.gmail.com
• Port: 587 with TLS enabled
• You must generate an App Password in your Google account (Security > 2-Step Verification > App Passwords). Regular Gmail passwords will not work if you have 2-factor authentication enabled.

Other common providers:

• Outlook/Hotmail: smtp.office365.com, port 587
• Yahoo: smtp.mail.yahoo.com, port 465
• Custom domain: Check with your hosting provider for SMTP details

You can also set a notification interval (e.g., one email every 5 minutes) to avoid inbox flooding when there is continuous motion, like wind blowing tree branches in the camera’s view.

Yes, MotionEyeOS integrates well with Home Assistant, and the setup is straightforward. MotionEyeOS exposes each camera as an MJPEG stream over HTTP, which Home Assistant can pull directly into its dashboard.

Method 1: MJPEG Camera Integration (recommended)

1. In Home Assistant, go to Settings > Devices & Services > Add Integration
2. Search for “MJPEG IP Camera”
3. Enter the stream URL for your camera:
   • Camera 1: http://<pi-ip>:8081
   • Camera 2: http://<pi-ip>:8082
   • Camera 3: http://<pi-ip>:8083 (and so on)
4. Enter the surveillance user credentials if you have set them in motionEye
5. Your camera feed will now appear as an entity in Home Assistant

Method 2: motionEye Integration Add-on

Home Assistant also has a dedicated motionEye integration (available through HACS or built-in) that provides deeper control, including the ability to manage camera settings and receive motion events directly as Home Assistant events.

Method 3: Webhooks for motion-triggered automations

MotionEyeOS can fire an HTTP request (webhook) whenever motion is detected. In the camera settings, scroll to “Motion Notifications” and enable “Call a Web Hook.” Point the URL to a Home Assistant webhook endpoint. This lets you trigger automations like:

• Turning on porch lights when the front door camera detects motion
• Sending a push notification to your phone
• Recording a clip from a different camera
• Triggering an alarm siren via a smart plug

Storage requirements depend on your resolution, frame rate, number of cameras, and whether you record continuously or only on motion. Here are real-world estimates to help you plan:

Motion-triggered recording (most common setup):

• 640×480 @ 10 fps: 500 MB – 2 GB per camera per day (in a moderately active area like a front porch)
• 1280×720 @ 15 fps: 2 – 5 GB per camera per day
• 1920×1080 @ 15 fps: 5 – 12 GB per camera per day

Continuous recording (24/7):

• 640×480 @ 10 fps: 3 – 5 GB per camera per day
• 1280×720 @ 15 fps: 8 – 15 GB per camera per day
• 1920×1080 @ 15 fps: 15 – 30 GB per camera per day

Storage recommendations by use case:

• 16 GB SD card: Enough for 1 camera with motion-triggered recording for 3-5 days at 720p
• 32 GB SD card: Good for 1-2 cameras with motion recording for about a week
• 64 GB SD card: Suitable for 2-3 cameras with motion recording for 5-7 days
• External USB drive (500 GB+): Recommended for multi-camera setups or if you want several weeks of retention
• Network share (NAS): Best option for long-term storage with terabytes of capacity

MotionEyeOS includes an automatic disk cleanup feature that deletes the oldest recordings when storage reaches a threshold you set (e.g., 90% full). This prevents the system from running out of space and crashing.

MotionEyeOS and Frigate NVR are both popular open-source surveillance solutions, but they target different users with different hardware and skill levels. Here is a detailed comparison:

MotionEyeOS – Best for simplicity and Pi-based setups

• Installation: Flash an SD card and boot. No Linux knowledge needed. Takes 5 minutes.
• Hardware: Runs directly on Raspberry Pi 1-4 and similar ARM boards. No additional hardware required.
• Detection: Basic pixel-change motion detection. Detects any movement but cannot distinguish between a person, car, animal, or swaying tree.
• Interface: Built-in web dashboard accessible from any browser.
• Resource usage: Under 100 MB RAM. Works on a Pi Zero with a single camera.
• Cost: Free. Only the Pi and camera.

Frigate NVR – Best for smart detection and power users

• Installation: Requires Docker, YAML configuration files, and more technical setup. Plan 30-60 minutes minimum.
• Hardware: Needs a Pi 4 (4 GB+), mini PC, or NAS. Strongly benefits from a Google Coral TPU ($25-60) for AI detection without high CPU usage.
• Detection: AI-powered object detection using machine learning models. Identifies people, cars, cats, dogs, and other objects. Dramatically reduces false alerts.
• Interface: Web UI with live view, event timeline, and object filtering. Deep Home Assistant integration.
• Resource usage: 1-2 GB RAM minimum. CPU-heavy without a Coral TPU.
• Cost: Free software, but the Coral TPU is a recommended additional purchase.

Bottom line: Choose MotionEyeOS if you want a dead-simple camera system on a spare Pi with minimal fuss. Choose Frigate if you are tired of false motion alerts (wind, shadows, animals) and want a system that only notifies you when an actual person or car is detected.

MotionEyeOS does not have a built-in over-the-air (OTA) update mechanism. Updating requires downloading a new image and flashing a fresh SD card. Here is the complete process:

Step 1: Back up your current settings

Before updating, save your camera configurations so you do not have to redo them from scratch. Connect to your Pi via SSH (default port 22, username admin) and copy the configuration directory:

scp -r admin@<pi-ip>:/data/etc ./motioneyeos-backup/

This directory contains your camera settings, motion detection parameters, Wi-Fi configuration, and user passwords.

Step 2: Download and flash the new image

1. Download the latest image for your board from our download section
2. Flash it to a new SD card (keep your old card as a fallback)
3. If using Wi-Fi, add the wpa_supplicant.conf file to the boot partition

Step 3: Boot and restore settings

1. Insert the new SD card and power on the Pi
2. Wait for the first boot to complete (1-2 minutes)
3. SSH into the Pi and copy your backed-up config files back to /data/etc/
4. Reboot the Pi: reboot

Current version status:

• Latest stable release: v20200606 (June 6, 2020)
• Pre-release build: dev20201026 (October 26, 2020) – available on GitHub but not marked as stable
• Most users are already running the latest version since no new stable releases have been published since 2020

A laggy or stuttering video feed in MotionEyeOS is usually caused by one of several common issues. Here is how to diagnose and fix each one:

1. Resolution and frame rate too high for your board

This is the most common cause. Each Pi model has different processing limits:

• Pi Zero / Pi 1: Maximum comfortable: 640×480 at 5-10 fps for a single camera
• Pi 2: 720p at 10-15 fps for one camera, 640×480 for two cameras
• Pi 3: 720p at 15 fps for 2-3 cameras, or 1080p for one camera
• Pi 4: 1080p at 15 fps for 2 cameras, or 720p for 3-4 cameras

To fix: Open camera settings in the motionEye dashboard and lower the Video Resolution and Frame Rate.

2. Underpowered power supply

A Pi that does not get enough current will throttle its CPU to prevent damage. You will often see a yellow lightning bolt icon on screen (if connected to a monitor) or experience random freezes. Use a quality power supply rated at 2.5A (Pi 3) or 3A (Pi 4). Cheap phone chargers are often not sufficient.

3. Network bottleneck (Wi-Fi vs Ethernet)

Wi-Fi adds latency and can drop frames, especially if the Pi is far from the router or there is interference. Switching to a wired Ethernet connection typically reduces feed latency by 50-200ms.

4. IP camera using RTSP instead of MJPEG

RTSP streams require the Pi to decode H.264 or H.265 video frames, which is CPU-intensive. MJPEG streams send individual JPEG frames that are much simpler to process. If your IP camera supports both protocols, switch to MJPEG for lower CPU usage.

5. SD card too slow

If you are recording video to the SD card and the card’s write speed is too low, it can cause the whole system to stall. Use a Class 10 or UHS-I rated card. Better yet, store recordings on a USB drive or network share.

The “unable to open video device” error means MotionEyeOS cannot detect or access your camera hardware. This can happen with USB webcams, Pi Camera Modules, or misconfigured network cameras. Here are the fixes for each camera type:

For USB Webcams:

1. Unplug and reconnect the webcam, then reboot the Pi
2. Verify UVC compatibility – MotionEyeOS uses the Video4Linux (V4L2) driver framework. Most modern webcams are UVC-compatible, but very old or exotic models may not be. Check the Linux UVC driver device list if unsure.
3. Avoid USB hubs – Connect the webcam directly to the Pi’s USB port. Hubs can cause power or bandwidth issues.
4. Check power – Some webcams draw too much power for the Pi’s USB port. Try a powered USB hub if the camera requires more current.
5. Verify detection via SSH: Log into the Pi and run ls /dev/video*. You should see /dev/video0 (or similar). If nothing appears, the camera is not being recognized at the hardware level.

For Raspberry Pi Camera Module (CSI):

1. Check the ribbon cable – The most common issue. Make sure the cable is firmly seated in the CSI connector on both the camera board and the Pi. The silver contacts should face the correct direction (toward the Ethernet/USB ports on most Pi models).
2. Verify camera detection: SSH in and run vcgencmd get_camera. You should see supported=1 detected=1. If detected=0, the cable connection or camera module has a problem.
3. Check for physical damage – Inspect the ribbon cable for tears, creases, or bent pins. These cables are fragile.

For Pi 4 with USB 3.0 webcams:

Some USB 3.0 webcams have compatibility issues with the Pi 4’s USB 3.0 controller. Try plugging the camera into a USB 2.0 port (the black ports, not the blue ones) as a workaround.

General troubleshooting:

• SSH in and check the system log: cat /var/log/messages | grep -i video
• If multiple cameras are connected, make sure each is assigned a unique device path in motionEye settings
• Reboot the Pi after any cable changes: reboot

Yes, MotionEyeOS can automatically upload motion-triggered snapshots and video clips to Google Drive. This is useful as an off-site backup – if someone steals the Pi or the SD card fails, your footage is still safe in the cloud.

How to set up Google Drive upload:

1. Open the motionEye web interface and click the settings icon (wrench) for the camera you want to configure
2. Scroll down to the “File Storage” section
3. Enable “Upload Media Files”
4. Select “Google Drive” as the upload service
5. Click the authorization link that appears. This opens a Google OAuth page where you grant MotionEyeOS permission to write files to your Drive.
6. Copy the authorization code from Google and paste it back into the motionEye settings
7. Set the upload folder name (e.g., “MotionEyeOS/FrontDoor”)
8. Choose what to upload: snapshots only, videos only, or both
9. Click Apply

Important settings to configure:

• Upload interval: How often files are pushed to Drive. Setting this too low can overload a Pi Zero’s CPU.
• File retention in Drive: MotionEyeOS does not automatically clean up old files in Google Drive. You will need to manually delete old footage or set up a Google Drive automation to manage storage.

Dropbox is also supported as an alternative cloud destination. The setup process is similar – enable Dropbox in File Storage settings and authorize through OAuth.

Storage considerations: Google Drive offers 15 GB free. A single camera generating 1 GB of motion-triggered clips per day would fill this in about two weeks. If you need more, upgrade to Google One (100 GB for $1.99/month) or use Dropbox with similar pricing.

MotionEyeOS works partially offline. The core surveillance functions operate without any internet connection, but some features require network access. Here is the full breakdown:

Works without internet:

• Motion detection – The motion detection engine runs locally on the Pi and does not need internet
• Local recording – Video clips and snapshots are saved to the SD card, USB drive, or attached storage
• Timelapse generation – Timelapse movies are created locally from stored frames
• Web interface on LAN – You can still access the motionEye dashboard from any device on the same local network, even with no internet connection
• Scheduling – Recording schedules and working hours continue to operate based on the Pi’s internal clock

Requires internet:

• Email notifications – Sending alerts via SMTP needs an internet connection
• Cloud uploads – Google Drive and Dropbox uploads will fail without internet and queue up
• Remote access – Viewing cameras from outside your local network (via port forwarding or VPN) needs internet
• Time synchronization – The Pi does not have a hardware real-time clock. Without internet, timestamps may drift after reboot. You can fix this by adding a $5 RTC module (DS3231)

Requires local network (but not internet):

• Initial setup – You need to access the web interface from a browser, which requires your device and the Pi to be on the same local network
• IP camera streams – Network cameras communicate over your LAN, which works without internet
• Network storage – SMB/CIFS shares on your local NAS work without internet

Fully isolated deployment (no network at all): If you need a camera with zero network connectivity, connect a USB webcam and store recordings on a USB drive. You will not be able to access the web interface remotely, but recordings will still be captured. To review footage, plug the USB drive into a computer.

Several open-source and commercial surveillance platforms can serve as alternatives to MotionEyeOS, each with different strengths. Here is a detailed comparison of the top options:

1. motionEye (standalone installation)

• What it is: The same web interface as MotionEyeOS, installed as an application on top of an existing Linux OS (Raspberry Pi OS, Debian, Ubuntu)
• Best for: Users who want the motionEye experience on Pi 5 or with a more up-to-date OS
• Install: sudo pip install motioneye on any Linux system
• Pros: Pi 5 support, OS updates separate from motionEye updates, access to full Linux tools
• Cons: Setup takes longer than flashing an SD card, not as “appliance-like”

2. Frigate NVR

• What it is: A Docker-based NVR with real-time AI object detection using machine learning
• Best for: Users who need smart alerts (only notify when a person or car is detected, not every moving shadow)
• Pros: AI detection (people, cars, animals), deep Home Assistant integration, event-based recording saves storage
• Cons: Requires Docker knowledge, benefits greatly from a Google Coral TPU ($25-60), needs Pi 4 (4 GB) or better hardware

3. ZoneMinder

• What it is: A mature, full-featured NVR platform that has been in development since 2002
• Best for: Large installations with many cameras on x86 server hardware
• Pros: Supports dozens of cameras, extensive recording and playback features, active development community
• Cons: Heavy on resources (not suitable for Pi), complex web interface, steep learning curve for setup

4. Shinobi

• What it is: A Node.js-based open-source CCTV platform with a modern web interface
• Best for: Users who want a modern-looking dashboard with WebSocket-based live streaming
• Pros: Clean UI, multi-user support with permission levels, plugin system for custom features
• Cons: Resource-hungry (not ideal for Pi Zero or Pi 1), can be complex to configure

5. Blue Iris (commercial)

• What it is: A commercial Windows NVR with a one-time $65 license
• Best for: Windows users who want a polished, reliable, feature-rich NVR without the DIY setup
• Pros: Excellent IP camera support, AI detection add-on, very stable, active development
• Cons: Windows only, paid, does not run on Pi or Linux

6. Agent DVR (iSpy)

• What it is: Free open-source DVR software with optional cloud features
• Best for: Cross-platform users who want a free alternative to Blue Iris
• Pros: Runs on Windows, Linux, and macOS. Optional cloud remote access.
• Cons: Cloud features require a subscription, desktop app feel rather than embedded system

Setting a static IP address ensures your MotionEyeOS Pi always has the same network address, making it easy to bookmark the dashboard URL and preventing integrations (like Home Assistant) from breaking when the IP changes. There are two methods:

Method 1: Through the motionEye web interface (easiest)

1. Open the motionEye dashboard in your browser
2. Click the gear icon in the top-left to open main settings
3. Scroll to the “Network” section
4. Change from “DHCP” to “Manual (Static IP)”
5. Fill in the following fields:
   • IP Address: Your desired static IP (e.g., 192.168.1.50)
   • Subnet Mask: Usually 255.255.255.0
   • Gateway: Your router’s IP (e.g., 192.168.1.1)
   • DNS Server: Your router’s IP or 8.8.8.8 (Google DNS)
6. Click Apply. The Pi will reboot with the new static IP.

Method 2: DHCP reservation on your router (recommended)

This approach assigns a fixed IP to the Pi from the router side, without changing any settings on the Pi itself:

1. Log into your router’s admin panel (usually at 192.168.1.1 or 192.168.0.1)
2. Find the DHCP reservation or Address reservation section (location varies by router brand)
3. Find your MotionEyeOS Pi in the connected devices list (look for the hostname starting with “meye-“)
4. Copy the Pi’s MAC address and assign it a fixed IP address
5. Save and reboot the router if required

Important: Whichever method you use, pick an IP address outside your router’s DHCP range to avoid conflicts. For example, if your router assigns DHCP addresses from .100 to .200, use a static IP in the .2 to .99 range (like 192.168.1.50).

Since MotionEyeOS is a full operating system flashed to an SD card (not a software application installed on top of another OS), “uninstalling” it means wiping and reformatting the SD card. The process is straightforward and takes just a few minutes.

Before you uninstall – back up your data:

• Recordings and snapshots: If you stored footage on the SD card, copy it off before reformatting. SSH into the Pi and check /data/output/ for saved media files.
• Configuration files: If you might reinstall MotionEyeOS later, back up /data/etc/ via SCP so you can restore your camera settings.

How to wipe the SD card:

Windows:

1. Insert the SD card into your computer
2. Download and run the SD Card Formatter tool from the SD Association (free). It handles multiple partitions cleanly.
3. Alternatively, open Disk Management (right-click Start > Disk Management), delete all partitions on the card, then create a new FAT32 volume.

macOS:

1. Open Disk Utility (Applications > Utilities)
2. Select the SD card from the sidebar
3. Click Erase, choose MS-DOS (FAT) format, and click Erase

Linux:

1. Open a terminal and identify your SD card device: lsblk
2. Unmount all partitions: sudo umount /dev/sdX*
3. Wipe the partition table: sudo wipefs -a /dev/sdX
4. Create a new partition and format: use fdisk, parted, or the gparted GUI tool

Why the card may show as smaller than expected: After running a Linux OS like MotionEyeOS, the SD card typically has multiple partitions (boot, root, data). Windows may only show the boot partition size (e.g., 50 MB instead of 32 GB). Using SD Card Formatter or Disk Management to delete all partitions restores the full capacity.