# Turn an Old Android Phone Into a Security Camera (IP Webcam, Frigate)

> Reuse a spare Android phone as a home or shop camera: three setups from a five-minute app to Frigate with Home Assistant, plus the security and privacy rules that matter.

Source: https://www.epifive.com/blog/old-android-phone-security-camera-ip-webcam-frigate · Published 2026-11-21 · EpiFive

## Key takeaways

- A spare Android phone can act as a network camera with an app such as IP Webcam, with no new hardware to buy.
- Pick the simplest setup that meets your need, from a cloud app for convenience to local viewing for privacy or Frigate for detection.
- Never port-forward the camera to the internet; use a private network such as Tailscale for remote viewing.
- Frigate needs an always-on machine, and a phone's MJPEG stream makes Frigate re-encode video, which uses more CPU.
- Point the camera only at your own property and check the rules on audio and neighbors before you record.

An old Android phone can work as a security camera if it has a working camera, Wi-Fi and a safe way to stay powered. The simplest route is a camera app that you view from another device on your network. The more capable route is to feed the phone's stream into Frigate, an open-source recorder that detects people and objects, and to send alerts through Home Assistant.

This guide gives you three setups, ordered by effort, and the security, battery and privacy checks that decide whether a phone camera is a good idea at all.

## Who this is for and what you will have

This is for anyone with a spare Android phone who wants a camera for a hallway, shop counter, garage or pet corner without buying a dedicated camera. It suits beginners for the first two setups and comfortable-with-Docker users for the third.

By the end you will have a phone streaming video on your own network, a login set on that stream, a safe way to power and mount it, and, if you choose the third setup, motion and person detection with recordings stored on your own machine. You will also know what not to do: expose the camera to the internet, point it at a neighbor's property, or leave a swollen battery charging.

## Pick your path

| Path | Effort | Where video goes | Detection and recording | Best for |
|---|---|---|---|---|
| 1. Camera app with cloud viewing | About 5 minutes | Through the app maker's service | Depends on the app | A quick pet or baby-room check |
| 2. IP Webcam, local viewing only | 15 minutes | Stays on your Wi-Fi | None built in; you watch live | A private live view of a shop or garage |
| 3. IP Webcam into Frigate | One evening | Stays on your network | Person and object detection, recordings, alerts | A small home or shop that wants history and alerts |

Path 1 is the easiest but the video passes through a third party, so read the app's privacy policy before you point it at a room. Paths 2 and 3 keep video local. This guide gives the full steps for paths 2 and 3.

## Prerequisites

You need the following before you start.

- An Android phone that still boots reliably, with a working rear camera and a screen you can leave on or dim. Factory-reset it and sign out of your personal Google account first, so a camera phone does not hold your email or photos.
- A stable Wi-Fi signal where you will mount it. A phone that drops off Wi-Fi is a camera that misses events.
- A charger and a cable you trust, plus a mount or stand.
- For path 3: an always-on computer (a mini PC, an old desktop or a Raspberry Pi) running Linux with Docker. Frigate's installation page recommends Docker Compose and says to run it on bare-metal Debian-based distributions. It does not officially support Windows and does not recommend running in a virtual machine.

If your phone gets hot or its battery is weak, read the guides on [Android phone overheating](https://www.epifive.com/blog/android-phone-overheating-causes-fixes) and [checking and improving Android battery health](https://www.epifive.com/blog/android-phone-battery-health-check-improve) first.

## Prepare the phone

Do these steps once, whichever path you pick.

1. Factory-reset the phone, connect to Wi-Fi and install system updates. Skip adding a personal Google account unless the Play Store requires one for the app download; use a throwaway account if so.
2. Turn off anything you do not need: Bluetooth, location sharing and notifications.
3. Give the phone a fixed address. In your router's admin page, reserve a DHCP address for the phone so the camera URL does not change after a restart. The exact page name varies by router.
4. Clean the camera lens and choose a spot with a view of the door or counter rather than a bright window, since backlit scenes look dark.

### Power and battery safety

An always-plugged-in phone is the main hardware risk. Old lithium batteries can swell over time. Follow these rules:

- Remove the case so heat can escape, and avoid mounting the phone in direct sun, on top of a router or inside a closed box.
- Check the phone every week for a bulging back panel, a screen lifting from the frame or a phone that no longer lies flat. If you see any of these, unplug it, stop using it and take it to the manufacturer's service channel. Do not press on the swelling or try to remove the battery yourself.
- Some phones offer a charge limit or protection mode. Google's Pixel battery page we opened covers Battery Saver and Adaptive Battery but not a charge limit, so look in your own phone's battery settings or the manufacturer's help pages for one; the setting name and location differ by brand.

## Path 2: IP Webcam with local viewing

IP Webcam is an Android app on Google Play (package `com.pas.webcam`) that, according to the Home Assistant documentation, turns an Android phone or tablet into a network camera. Home Assistant describes the stream the integration uses as MJPEG.

### Start the server

1. Install IP Webcam from Google Play and open it.
2. Open the app's settings and set a login and password for the video stream. The setting name is in the app's menu; look for the option that lets you enter a username and password for access. Choose a long, unique password, because anyone on your Wi-Fi who knows the address can otherwise watch.
3. Choose a modest video resolution for the first test. Lower resolution uses less bandwidth, less heat and less battery.
4. Scroll to the end of the menu and tap **Start Server**. Home Assistant's documentation says the app then shows the device's IP address on screen.

The app lists the addresses it serves. Use those exact addresses rather than guessing paths; this guide does not list the app's URL paths because the developer's own page we opened did not document them, and third-party lists differ.

### View it on your network

On another device on the same Wi-Fi, type the address the app shows into a browser or into a media player such as VLC that can open a network stream. Enter the username and password you set. You should see a live view and, if the page offers it, a snapshot or a stream address.

```text
http://PHONE_IP:PORT/   <- use the exact address shown on the phone screen
```

If you can see video, path 2 is working. Bookmark it on your own devices only.

### Limits of path 2

IP Webcam on its own gives you a live view. This guide did not confirm hands-on how it handles recording or motion alerts, and it is not a replacement for a recorder. If you need to see what happened while you were away, use path 3 or a dedicated camera.

## Path 3: IP Webcam into Frigate

Frigate is an open-source network video recorder with object detection. It runs on your own machine and reads camera streams. This path adds recordings, person detection and alerts.

### Understand the trade-off

Frigate's camera documentation says MJPEG cameras need the video encoded into H.264 for recording and restreaming, which "will use significantly more CPU than if the cameras supported h264 feeds directly." A phone app that serves MJPEG therefore costs more processing than a normal IP camera. A mini PC with hardware video decoding copes better than a Raspberry Pi. Start with a single camera and watch CPU use.

### Install Frigate with Docker Compose

Frigate's installation page recommends Docker Compose. Its generated example uses the image `ghcr.io/blakeblackshear/frigate:stable`, mounts a config folder at `/config` and a storage folder at `/media/frigate`, and publishes ports 8554 (RTSP), 8971 (authenticated UI and API) and 8555 (WebRTC). Generate the exact file from the installation page for your hardware rather than copying a version from a blog. A shortened outline looks like this:

```yaml
services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable
    shm_size: "512mb"          # update for your cameras
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /path/to/your/config:/config
      - /path/to/your/storage:/media/frigate
    ports:
      - "8971:8971"
      - "8554:8554"
      - "8555:8555/tcp"
      - "8555:8555/udp"
    environment:
      TZ: "UTC"
```

The page's own example also adds a tmpfs mount at `/tmp/cache` and `privileged: true` with the note that this may not be necessary for all setups. Include those lines from the page when you generate your file.

Two settings matter for stability:

- **Shared memory.** Docker's default shared memory is 64 MB. Frigate's page says it needs about 210 MB for two cameras detecting at 720p, and gives the per-camera formula `(width x height x 1.5 + 270480) / 1048576 x 25 frames`. A "Bus error" message usually means `shm_size` is too small.
- **Ports.** Port 8971 is the authenticated UI and API. Port 5000 is an internal, unauthenticated port, and the docs say access to it should be limited. Do not publish port 5000 to your network or the internet.

### Sign in the first time

According to Frigate's authentication page, Frigate generates an admin user and password on first start and prints them in the container logs. Read them from the logs, sign in on port 8971, and change the password under **Settings > Users**. Frigate requires a minimum password length of 12 characters.

### Re-encode the phone's stream with go2rtc

For MJPEG sources, Frigate's documentation shows a go2rtc stream that converts the feed to H.264 and then uses that restream as the camera input. Adapt the documented pattern. The stream address comes from your phone's screen; keep the credentials out of the file if you can by using environment variables as the docs describe.

```yaml
go2rtc:
  streams:
    old_phone: "ffmpeg:http://USER:PASSWORD@PHONE_IP:PORT/STREAM_PATH#video=h264#hardware"

cameras:
  old_phone:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/old_phone
          roles:
            - detect
            - record
    detect:
      width: 1280
      height: 720
```

The `#video=h264#hardware` form is the pattern in Frigate's MJPEG section, which notes that `#hardware` enables hardware acceleration. The `rtsp://127.0.0.1:8554/old_phone` input is the restream address that Frigate's go2rtc exposes for a named stream. Set `width` and `height` to match the stream, or leave them out and let Frigate detect the resolution. Each role can be assigned to only one input per camera, so one restream carrying both `detect` and `record` is the simple choice here.

Replace `STREAM_PATH` with the video path the IP Webcam app shows on its start screen. Frigate's docs do not describe IP Webcam specifically, so test the address in VLC first.

### Choose what to record

Frigate's recording page says continuous recording is disabled by default and the retention mode defaults to `motion`. Its documented structure lets you keep different durations per type:

```yaml
record:
  enabled: true
  continuous:
    days: 1
  motion:
    days: 2
  alerts:
    retain:
      days: 10
  detections:
    retain:
      days: 10
```

Those values are the page's illustrative example, not defaults. Pick numbers that fit your disk. Recordings are the main storage cost, so start with short retention and check free space after a week.

### Connect Home Assistant for alerts

Frigate's Home Assistant integration needs Frigate already running and Home Assistant's `mqtt` integration installed and configured first. Frigate must connect to the same MQTT broker. The documented steps are:

1. Install the Frigate integration through HACS, a default HACS repository: open HACS, search for "Frigate" and select it.
2. Restart Home Assistant.
3. Go to **Settings > Devices & Services > Add Integration > Frigate**.
4. Enter the Frigate `URL`. If Frigate runs on a separate machine, use the authenticated port 8971 so login is required. The docs warn that Frigate's default self-signed certificate makes HTTPS connections fail unless you use a valid certificate or disable TLS for that internal link.

The integration creates `camera`, `image`, `sensor`, `switch` and `binary_sensor` entities, including a motion binary sensor per camera, zone and object. You then build notifications in Home Assistant automations using those entities.

Home Assistant also has a separate, simpler Android IP Webcam integration. It uses local polling, creates a camera entity with an MJPEG stream plus switches and sensors, and sensor values stay `unknown` until you enable **Data logging > Enable data logging** in the app. Use it if you want phone controls in Home Assistant without Frigate.

## Secure the camera

A camera that watches your home is also an attack target. Treat it like any other device that holds private video.

- **Set a login on the phone's stream** and a strong password on Frigate. Do not leave either open on the LAN.
- **Never port-forward** the phone, Frigate port 5000, or the RTSP port to the internet. Public scanners find exposed cameras quickly.
- **For remote viewing, use a private network.** Tailscale is a private network, called a tailnet, that connects your own devices securely. Install the client on the Frigate machine and on your phone or laptop, then open Frigate's authenticated port over the tailnet address. Tailscale's documentation says signing up with a public email account puts you on the Personal plan with six free users; check the current pricing page before you rely on that.
- **Separate network if possible.** Put the camera and recorder on a guest or IoT network so a compromised device cannot reach your laptops.
- **Keep the phone updated** and uninstall apps you do not use. If the phone no longer gets security updates, keep it off any network that carries sensitive devices.
- **Restrict who has the Frigate admin account.** Create viewer users for family members instead of sharing the admin password.

## Privacy and legal checks

Where you aim the camera matters as much as how you set it up. This is general information, not legal advice.

- **Point it only at your own property.** The UK Information Commissioner's Office guidance for domestic CCTV says owners should aim to capture only their own property where possible, and that if a camera captures other areas, you should use filters or privacy blockers to block those parts. It also says that if you record beyond your boundary you should let people know, for example with a sign.
- **Audio is personal data too.** The same guidance treats sound like images, because voices count as personal information. Turn off audio recording unless you need it and have checked your local rules.
- **Check your own country's rules.** The ICO page covers the UK. If you are in the US, India or elsewhere, look up your local rules on recording neighbors, public spaces and audio, and on notices for shop cameras. This article did not verify India's or US rules from an official source, so confirm them locally before you record anyone other than yourself.
- **Tell people.** In a shop or workplace, a visible notice and a clear reason for recording is good practice, and retention should be as short as you need.

## Verify it works

Run through this list once the setup is done.

1. Walk through the camera's view and confirm the live image appears on a second device.
2. Restart the phone and check the stream returns on the same address. If it does not, enable the app's start-on-boot option if your version has one and the reserved DHCP address was kept.
3. In Frigate, open the camera and confirm a detection box appears when you walk in view. Check the Frigate logs for ffmpeg errors.
4. Trigger a test notification in Home Assistant and confirm it arrives on your phone.
5. Confirm from outside your home Wi-Fi, without Tailscale, that the camera is not reachable. Then connect over Tailscale and confirm it is.

## Troubleshooting

| Symptom | Likely cause | Fix |
|---|---|---|
| Video works in VLC but not in Frigate | Wrong stream path, or credentials not set in go2rtc | Copy the address from the app screen; test the exact string in VLC; check the go2rtc stream name matches the camera input |
| Frigate container logs "Bus error" | Shared memory too small, or PID limit reached | Raise `shm_size`, or raise `pids_limit` as Frigate's installation page describes |
| "Too many open files" errors | File limit too low | Raise `nofile` soft and hard limits to 65535, as Frigate's page recommends |
| High CPU on the Frigate machine | MJPEG re-encoding without hardware acceleration | Use `#hardware` where supported, lower the phone's resolution, or run fewer cameras |
| Stream stops after hours | Phone sleeping or killing the app | Keep the screen on or disable battery optimization for the app, and keep the phone on the charger |
| Home Assistant cannot connect to Frigate over HTTPS | Self-signed certificate | Use a valid certificate, or disable TLS for the internal connection as the docs describe |
| Phone is hot or the case is lifting | Battery stress or swelling | Stop charging, unplug, and have the phone serviced; do not keep using it |

## See also

- [Android Safe Mode: Find a Bad App and Fix a Crashing Phone](https://www.epifive.com/blog/android-safe-mode-remove-bad-app-fix-crashing-phone)
- [Lost or Stolen Phone: Find, Lock and Erase It on Android and iPhone](https://www.epifive.com/blog/find-lost-phone-android-iphone-steps)
- [Phone Storage Full: How to Free Up Space on Android and iPhone](https://www.epifive.com/blog/phone-storage-full-free-up-space-android-iphone)

## What we checked

- Opened the Frigate installation page (docs.frigate.video) on 2026-11-21: recommended Docker Compose, image `ghcr.io/blakeblackshear/frigate:stable`, ports 8554, 8971 and 8555, the 64 MB Docker default shared memory and the 210 MB needed for two 720p cameras, and the note that Windows is not officially supported.
- Recalculated Frigate's shared-memory formula for one 1280x720 camera: (1280 x 720 x 1.5 + 270480) / 1048576 x 25 = (1,382,400 + 270,480) / 1,048,576 x 25 = 1,652,880 / 1,048,576 x 25 = 39.4 MB, so two such cameras need about 79 MB for frames alone. Frigate's page quotes about 210 MB for two cameras, so we kept its figure as the safe number and did not claim ours replaces it.
- Opened Frigate's camera, camera-specific, authentication and recording pages the same day: roles `detect` and `record` and the one-input-per-role rule, the MJPEG-to-H.264 caveat and the go2rtc `#video=h264#hardware` pattern, generated admin password in the logs, the 12-character minimum, port 5000 being unauthenticated, and continuous recording being off by default.
- Opened Home Assistant's Android IP Webcam page and Frigate's Home Assistant integration page the same day and compared the labels: **Start Server**, **Settings > Devices & Services > Add Integration**, **Data logging > Enable data logging**, and the MQTT requirement.
- Opened the UK ICO's domestic CCTV page the same day and quoted its points on capturing only your own property, signs and audio.
- Opened the Tailscale installation page for the tailnet description and free-plan wording, and Google's Pixel battery help page to confirm it lists Battery Saver and Adaptive Battery but no charge limit.
- Not checked: the IP Webcam developer's own documentation and Google Play listing did not load usable content in this run, so the app's menu labels, URL paths and default port are not documented here; we did not install the app or run Frigate on a real phone or server, and we could not open Indian or US legal sources or a manufacturer's page on swollen batteries. The steps follow the cited documentation as of 2026-11-21.

Last tested: 2026-11-21

## References

- [Frigate: Installation](https://docs.frigate.video/frigate/installation/)
- [Frigate: Cameras](https://docs.frigate.video/configuration/cameras)
- [Frigate: Camera specific configurations (MJPEG cameras)](https://docs.frigate.video/configuration/camera_specific)
- [Frigate: Authentication](https://docs.frigate.video/configuration/authentication)
- [Frigate: Recording](https://docs.frigate.video/configuration/record)
- [Frigate: Home Assistant integration](https://docs.frigate.video/integrations/home-assistant)
- [Home Assistant: Android IP Webcam integration](https://www.home-assistant.io/integrations/android_ip_webcam/)
- [IP Webcam on Google Play](https://play.google.com/store/apps/details?id=com.pas.webcam)
- [Tailscale: Install](https://tailscale.com/kb/1017/install)
- [ICO: Domestic CCTV systems](https://ico.org.uk/for-the-public/domestic-cctv-systems/)
- [Google Pixel Help: Battery Saver and Adaptive Battery](https://support.google.com/pixelphone/answer/7015477)

## Frequently asked questions

### Can I use an old Android phone as a security camera?

Yes. A spare phone with a working camera and Wi-Fi can run a camera app such as IP Webcam, which turns an Android phone into a network camera. You can view it from a browser or media player on the same network, or feed it into software such as Frigate for motion and person detection.

### Is it safe to leave an old phone plugged in all the time?

It carries some risk because an old battery can swell. Remove the case, keep the phone somewhere cool and ventilated, check it regularly, and stop using it if the back bulges or the screen lifts. Replace the battery or retire the phone rather than keep charging it.

### Should I open a port on my router to watch the camera remotely?

No. Do not port-forward a phone camera to the internet. Use a private network tool such as Tailscale, which lets your own devices connect to each other, so the camera is never reachable by the public.

### Do I need Frigate to use a phone as a camera?

No. Frigate is optional. The phone app alone gives you a live view on your local network. Frigate adds recording, object detection and Home Assistant alerts, but it needs a separate always-on computer running Docker.

