Raspberry Pi IP Camera Build: RTSP Streaming with Pi 5 & Picamera2

The Verdict: Hardware Decision Matrix for 2026

Building a Raspberry Pi IP camera in 2026 means navigating the transition from legacy raspivid commands to the modern libcamera and picamera2 stack. Before wiring anything, you need to match your hardware to your streaming destination. The Pi 5's unified memory architecture and dedicated ISP (Image Signal Processor) make it the undisputed baseline for IP camera work, but the exact variant depends on your backend.

Bill of Materials and CSI Pin Mapping

The most common mistake builders make in 2026 is buying the wrong CSI ribbon cable. The Raspberry Pi 5 uses smaller, denser 22-pin CSI connectors, while the Camera Module 3 uses the legacy 15-pin connector. You cannot use a standard Pi 4 camera cable without an adapter.

Parts List

• Board: Raspberry Pi 5 (4GB) - ~$60
• Sensor: Raspberry Pi Camera Module 3 (Standard or Wide) - ~$30
• Cable: 200mm CSI Ribbon Cable (22-pin Pi 5 to 15-pin Camera) - ~$8
• Power: Official 27W USB-C PD Power Supply (Crucial for Pi 5 peripheral power limits) - ~$12
• Storage: 64GB microSD (A2 rated) or NVMe SSD via PCIe HAT

CSI Pin Mapping (22-pin to 15-pin)

The CSI interface carries both high-speed MIPI data lanes and I2C control signals. Here is the logical mapping from the Pi 5 board to the IMX708 sensor.

Step-by-Step: OS Prep and RTSP Server Setup

We will use mediamtx as our RTSP server. It is a zero-dependency, lightweight binary that replaces the aging rtsp-simple-server. The target OS is Raspberry Pi OS Bookworm (64-bit), which natively supports libcamera.

1. Flash the OS: Use Raspberry Pi Imager to flash Raspberry Pi OS Bookworm (64-bit) to your microSD. Enable SSH and configure WiFi in the Imager settings.
2. Update and Install Dependencies: SSH into the Pi and run:

   sudo apt update && sudo apt upgrade -y
   sudo apt install -y python3-picamera2 python3-libcamera ffmpeg

3. Install mediamtx: Download the latest ARM64 release of mediamtx.

   wget https://github.com/bluenviron/mediamtx/releases/download/v1.8.1/mediamtx_v1.8.1_linux_arm64v8.tar.gz
   tar -xzf mediamtx_v1.8.1_linux_arm64v8.tar.gz
   sudo mv mediamtx /usr/local/bin/

4. Start the RTSP Server: Run it in the background.

   mediamtx &

   Note: For a permanent setup, create a systemd service for mediamtx so it survives reboots.
5. Verify Camera Hardware: Before running Python, confirm the OS sees the sensor.

   libcamera-hello -t 5000

   If a 5-second preview window appears (or you see the ISP processing frames in the terminal), your hardware is wired correctly.

Python RTSP Streaming Script (Picamera2)

This script targets the Raspberry Pi 5 (4GB/8GB) running Bookworm. It initializes the IMX708 sensor, configures a 1080p H.264 hardware-encoded video stream, and pipes the raw bitstream directly into ffmpeg, which pushes it to the local mediamtx RTSP endpoint.

import time
import logging
import subprocess
from picamera2 import Picamera2
from picamera2.encoders import H264Encoder
from picamera2.outputs import FfmpegOutput

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

# Target RTSP endpoint (mediamtx default port is 8554)
RTSP_URL = 'rtsp://localhost:8554/pi_cam_stream'

# Ffmpeg command to read from stdin (-i -) and copy the H264 stream to RTSP
FFMPEG_CMD = (
    f'ffmpeg -loglevel warning -y -i - '
    f'-c:v copy -f rtsp {RTSP_URL}'
)

def main():
    logging.info('Initializing Picamera2 for Raspberry Pi 5...')
    picam2 = Picamera2()
    
    # Create a video configuration: 1080p, YUV420 format for H264 encoder
    video_config = picam2.create_video_configuration(
        main={'size': (1920, 1080), 'format': 'YUV420'},
        controls={'FrameRate': 30}
    )
    picam2.configure(video_config)
    
    # Initialize hardware H264 encoder at 4 Mbps
    encoder = H264Encoder(bitrate=4000000)
    output = FfmpegOutput(FFMPEG_CMD)
    
    try:
        picam2.start_recording(encoder, output)
        logging.info(f'Successfully streaming to {RTSP_URL}')
        logging.info('Press Ctrl+C to stop.')
        
        # Keep the main thread alive
        while True:
            time.sleep(1)
            
    except KeyboardInterrupt:
        logging.info('Interrupt received. Stopping stream...')
    except RuntimeError as e:
        logging.error(f'Hardware allocation failed: {e}')
        logging.error('Check if another process is holding the camera.')
    except Exception as e:
        logging.error(f'Unexpected streaming error: {e}')
    finally:
        # Graceful teardown to prevent ISP lockups
        logging.info('Cleaning up camera resources...')
        try:
            picam2.stop_recording()
        except Exception:
            pass
        picam2.close()
        logging.info('Camera closed safely.')

if __name__ == '__main__':
    main()

Debugging: Camera Not Detected and Allocation Errors

The transition to libcamera introduced stricter resource management. If your script crashes, do not guess. Read the exact error string and follow the ranked causes below.

Exact Error Strings and Ranked Causes

The First Three Things to Check When It Fails

1. Physical Cable Orientation: The contacts on the CSI ribbon cable must face the green PCB of the Pi and the green PCB of the camera module. If the blue insulating tape is facing the board components, the I2C and MIPI lanes are inverted, and the Pi will silently fail to enumerate the sensor.
2. Isolate the Hardware: Always run libcamera-hello -t 2000 from the CLI before running your Python script. If the CLI tool fails, your Python code is fine; your hardware or OS configuration is the problem.
3. Check for Zombie Processes: The Pi's ISP can only serve one master process at a time. If your previous Python script crashed without hitting the finally block, the camera remains locked. Run sudo killall python3 and sudo killall ffmpeg to clear the pipeline.

Extending the Build: Frigate NVR and Simplification

Once your RTSP stream is stable, you have a fork in the road for how to consume the video data.

How to Extend (Frigate NVR Integration)

If you want AI-based person/vehicle detection, feed the RTSP URL into Frigate NVR running on a beefier machine (like an Intel NUC or a Pi 5 with a Coral USB Accelerator). In your Frigate config.yml, add the Pi as a camera source:

cameras:
  pi_workshop:
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.50:8554/pi_cam_stream
          roles:
            - detect
    detect:
      width: 1920
      height: 1080
      fps: 15

Note: Frigate will sub-sample the stream to 5-10 FPS for object detection to save CPU, while recording the full 30 FPS stream to disk.

How to Simplify (Drop the Python)

If you don't need custom Python logic (like overlaying sensor data or triggering GPIO relays based on motion), you can bypass the Python script entirely. Use the native libcamera-vid binary, which is heavily optimized in C++ for the Pi's ISP. Run this as a systemd service:

libcamera-vid -t 0 --inline --listen -o rtsp://localhost:8554/pi_cam_stream

This single command handles the H.264 encoding and RTSP packaging natively, using roughly 15% less CPU than the Python + ffmpeg pipe method.

Building a Raspberry Pi IP camera is no longer a hacky workaround; with the Pi 5 and the IMX708 sensor, it is a production-grade surveillance node. Stick to the 22-pin adapter cable, use picamera2 for hardware-accelerated encoding, and let mediamtx handle the network transport. Your stream will be online, stable, and ready for NVR ingestion in under twenty minutes.