How to enable webcam streaming on the Snapmaker U1

The Snapmaker U1 has a built-in camera, but getting it to stream reliably to SimplyPrint requires some extra configuration. This guide covers two methods to enable webcam support - using custom firmware or running a keepalive script on your local network.

Snapmaker has been supportive of community modifications and may open up more features natively in future firmware updates, such as SSH access or public source code. Until then, these workarounds provide reliable webcam streaming.

Table of contents

1. Choose your method
2. Method A: Custom firmware
3. Method B: Stock firmware + external keepalive

• Step 1: Get your access token from Fluidd
• Step 2: Choose your setup method
• Step 3: Configure Moonraker

4. Verify it's working
5. Troubleshooting
6. Important notes
7. Technical details
8. Credits

Choose your method

There are two ways to enable webcam support with SimplyPrint on the Snapmaker U1:

Method A: Custom firmware

paxx12's Extended Firmware adds native webcam streaming directly to the printer.

Features:

• Hardware-accelerated camera with WebRTC streaming
• SSH access and debug features
• V4L2 controls and settings persistence
• Active community support via Snapmaker Discord

Installation: Download from the GitHub Releases page and flash via the printer's update mechanism. See the project documentation for detailed instructions.

Method B: Stock firmware + external keepalive

This method keeps your firmware 100% stock by running a small background script on a separate device. Based on a community solution shared by Snapmaker Discord members and Reddit.

The Snapmaker U1's built-in camera has a snapshot endpoint, but it stops updating unless something "wakes" it periodically. The keepalive script sends a wake signal every few seconds to keep the camera feed active for SimplyPrint.

How it works

The U1's camera enters an idle state when nothing is actively requesting the feed. Once idle, the snapshot image stops refreshing.

The keepalive script solves this by sending a periodic "wake" signal to the printer over WebSocket. As long as the script is running, the camera stays active and SimplyPrint receives an up-to-date feed.

Step 1: Get your access token from Fluidd

The printer requires an authentication token. To find it:

1. Open your web browser and go to your U1's IP address (e.g., http://192.168.1.100)
2. Press F12 to open Developer Tools
3. Go to the Network tab and select WS (WebSocket) filter
4. Refresh the page (F5)
5. Look for a request that starts with websocket?token=
6. Copy the token value (the part after token=)

Step 2: Choose your setup method

Select one of the options below. Option A is recommended if you have Docker installed.

Option A: Docker command (recommended)

Replace the IP and TOKEN values, then run:

Linux/macOS (Bash):

docker run -d \
  --name snapmaker-cam \
  --restart unless-stopped \
  -e PRINTER_IP="192.168.1.100" \
  -e TOKEN="YOUR_TOKEN_HERE" \
  python:3.12-slim sh -c '
    pip install -q websocket-client && python -c "
import json, time, os
from websocket import create_connection
IP = os.environ[\"PRINTER_IP\"]
TK = os.environ[\"TOKEN\"]
while True:
    try:
        ws = create_connection(f\"ws://{IP}/websocket?token={TK}\", timeout=5)
        ws.send(json.dumps({\"id\": 1, \"jsonrpc\": \"2.0\", \"method\": \"camera.start_monitor\", \"params\": {\"domain\": \"lan\", \"interval\": 0}}))
        ws.close()
        print(f\"[{time.strftime(\"%H:%M:%S\")}] OK\")
    except Exception as e:
        print(f\"Error: {e}\")
    time.sleep(10)
"'

Windows (PowerShell):

docker run -d `
  --name snapmaker-cam `
  --restart unless-stopped `
  -e PRINTER_IP="192.168.1.100" `
  -e TOKEN="YOUR_TOKEN_HERE" `
  python:3.12-slim sh -c '
    pip install -q websocket-client && python -c "
import json, time, os
from websocket import create_connection
IP = os.environ[\"PRINTER_IP\"]
TK = os.environ[\"TOKEN\"]
while True:
    try:
        ws = create_connection(f\"ws://{IP}/websocket?token={TK}\", timeout=5)
        ws.send(json.dumps({\"id\": 1, \"jsonrpc\": \"2.0\", \"method\": \"camera.start_monitor\", \"params\": {\"domain\": \"lan\", \"interval\": 0}}))
        ws.close()
        print(f\"[{time.strftime(\"%H:%M:%S\")}] OK\")
    except Exception as e:
        print(f\"Error: {e}\")
    time.sleep(10)
"'

Manage the container:

docker logs -f snapmaker-cam    # View logs
docker restart snapmaker-cam    # Restart
docker stop snapmaker-cam       # Stop
docker rm snapmaker-cam         # Remove

Option B: Docker Compose

For a cleaner setup, create a file called docker-compose.yml:

version: "3.8"

services:
  snapmaker-cam-keepalive:
    image: python:3.12-slim
    container_name: snapmaker-cam-keepalive
    restart: unless-stopped
    environment:
      PRINTER_IP: "192.168.1.100"      # Your U1's IP address
      TOKEN: "YOUR_TOKEN_HERE"          # Token from Step 1
      POLL_INTERVAL: "10"               # Seconds between wake signals
    command:
      - sh
      - -c
      - |
        pip install --no-cache-dir websocket-client && python - <<'PY'
        import json, time, os
        from websocket import create_connection

        PRINTER_IP = os.environ["PRINTER_IP"]
        TOKEN = os.environ["TOKEN"]
        POLL_INTERVAL = int(os.environ.get("POLL_INTERVAL", "10"))

        WS_URL = f"ws://{PRINTER_IP}/websocket?token={TOKEN}"

        def wake_camera():
            payload = {
                "id": int(time.time() * 1000),
                "jsonrpc": "2.0",
                "method": "camera.start_monitor",
                "params": {"domain": "lan", "interval": 0}
            }
            try:
                ws = create_connection(WS_URL, timeout=5)
                ws.send(json.dumps(payload))
                ws.close()
                print(f"[{time.strftime('%H:%M:%S')}] Camera wake signal sent")
            except Exception as e:
                print(f"[{time.strftime('%H:%M:%S')}] Error: {e}")

        print(f"Starting camera keepalive for {PRINTER_IP}")
        print(f"Polling every {POLL_INTERVAL} seconds")

        while True:
            wake_camera()
            time.sleep(POLL_INTERVAL)
        PY

Start the service:

docker compose up -d

View logs:

docker compose logs -f

Option C: Systemd service (no Docker)

For systems without Docker (e.g., Raspberry Pi OS Lite), use systemd directly.

One-liner setup - replace IP and TOKEN, then run:

sudo tee /etc/systemd/system/snapmaker-cam.service > /dev/null <<'EOF'
[Unit]
Description=Snapmaker U1 Camera Keepalive
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
Restart=always
RestartSec=10
ExecStart=/usr/bin/python3 -c "\
import json,time;\
from websocket import create_connection;\
IP,TK='192.168.1.100','YOUR_TOKEN_HERE';\
print(f'Keepalive started for {IP}');\
[None for _ in iter(lambda: (create_connection(f'ws://{IP}/websocket?token={TK}',timeout=5).send(json.dumps({'id':1,'jsonrpc':'2.0','method':'camera.start_monitor','params':{'domain':'lan','interval':0}})) or print(f'[{time.strftime(\"%H:%M:%S\")}] OK'),time.sleep(10)),None)]"

[Install]
WantedBy=multi-user.target
EOF

Install dependency and start:

sudo pip3 install websocket-client
sudo systemctl daemon-reload
sudo systemctl enable --now snapmaker-cam

Manage the service:

sudo systemctl status snapmaker-cam    # Check status
sudo journalctl -u snapmaker-cam -f    # View logs
sudo systemctl restart snapmaker-cam   # Restart
sudo systemctl stop snapmaker-cam      # Stop

Option D: Standalone Python script

If you prefer a readable script file:

1. Install the dependency:

   pip3 install websocket-client

2. Create /opt/snapmaker-cam.py:

#!/usr/bin/env python3
"""Snapmaker U1 Camera Keepalive - keeps the camera feed active."""
import json, time
from websocket import create_connection

PRINTER_IP = "192.168.1.100"    # Your U1's IP
TOKEN = "YOUR_TOKEN_HERE"       # Token from Step 1

while True:
    try:
        ws = create_connection(f"ws://{PRINTER_IP}/websocket?token={TOKEN}", timeout=5)
        ws.send(json.dumps({"id": 1, "jsonrpc": "2.0", "method": "camera.start_monitor",
                            "params": {"domain": "lan", "interval": 0}}))
        ws.close()
        print(f"[{time.strftime('%H:%M:%S')}] OK")
    except Exception as e:
        print(f"Error: {e}")
    time.sleep(10)

3. Run manually or create a systemd service pointing to the script:

   python3 /opt/snapmaker-cam.py

Step 3: Configure Moonraker

Add the following to your moonraker.conf file on the U1:

[webcam static_file_camera]
location: printer
service: custom
stream_url: http://localhost:7125/server/files/camera/monitor.jpg
snapshot_url: http://localhost:7125/server/files/camera/monitor.jpg
target_fps: 1

[simplyprint]
webcam_name: static_file_camera

How to edit moonraker.conf:

1. Open Fluidd in your browser (http://YOUR_PRINTER_IP)
2. Click the Configuration icon in the left sidebar (looks like {.})
3. Find and click on moonraker.conf in the file list

4. Scroll to the bottom of the file and add the configuration block above
5. Click SAVE & RESTART in the top-right corner to apply changes

The camera feed should now stay active as long as your keepalive script is running, and SimplyPrint will use the static_file_camera webcam.

Verify it's working

Once everything is configured, check SimplyPrint to confirm the webcam is streaming:

The "live" indicator confirms the stream is active and updating.

Troubleshooting

Important notes

• Always-on requirement: The keepalive script must run continuously on a device that is always powered on and connected to the same local network as the printer. If the device shuts down or loses network connectivity, the webcam feed will stop updating.
• Same network: The script and printer must be on the same local network. Do not expose the printer or this script to the internet.
• Token security: The access token grants control over your printer. Do not share it publicly.
• Resource usage: The script is lightweight and uses minimal CPU and bandwidth.

Technical details

The keepalive script - discovered by the community - works by sending a JSON-RPC command over WebSocket:

{
  "jsonrpc": "2.0",
  "method": "camera.start_monitor",
  "params": {"domain": "lan", "interval": 0}
}

This tells the U1 to start updating the camera snapshot at /server/files/camera/monitor.jpg. Without periodic calls, the camera goes idle and the snapshot becomes stale.

Method C: Custom SimplyPrint integration

A native SimplyPrint integration for the Snapmaker U1 is currently in development. This will provide a simpler setup experience without requiring custom firmware or external keepalive scripts.

Release date is to be determined. More information will be shared in the SimplyPrint Discord server at a later date.

Credits

This solution is based on work shared by the Snapmaker community, originally by @atfives3dprint on Discord, with additional contributions from Reddit user taylormadearmy.

Updated on: 20/01/2026