frigate/docs/docs/frigate/network_requirements.md

id, title

id	title
network_requirements	Network Requirements

Network Requirements

Frigate is designed to run locally and does not require a persistent internet connection for core functionality. However, certain features need internet access for initial setup or ongoing operation. This page describes what connects to the internet, when, and how to control it.

How Frigate Uses the Internet

Frigate's internet usage falls into three categories:

1. One-time model downloads: ML models are downloaded the first time a feature is enabled, then cached locally. No internet is needed on subsequent startups.
2. Optional cloud services: Features like Frigate+ and Generative AI connect to external APIs only when explicitly configured.
3. Build-time dependencies: Components bundled into the Docker image during the build process. These require no internet at runtime.

:::tip

After initial setup, Frigate can run fully offline as long as all required models have been downloaded and no cloud-dependent features are enabled.

:::

One-Time Model Downloads

The following models are downloaded automatically the first time their associated feature is enabled. Once cached in /config/model_cache/, they do not require internet again.

Feature	Models Downloaded	Source
Semantic search	Jina CLIP v1 or v2 (ONNX) + tokenizer	HuggingFace
Face recognition	FaceNet, ArcFace, face detection model	GitHub
License plate recognition	PaddleOCR (detection, classification, recognition) + YOLOv9 plate detector	GitHub
Bird classification	MobileNetV2 bird model + label map	GitHub
Custom classification (training)	MobileNetV2 ImageNet base weights (via Keras)	Google storage
Audio transcription	Whisper or Sherpa-ONNX streaming model	HuggingFace / OpenAI

:::note

The MobileNetV2 base weights are the one exception to the /config/model_cache/ rule. They are also the only entry that is not downloaded when the feature is enabled: Frigate fetches them when a training run actually starts.

:::

Hardware-Specific Detector Models

If you are using one of the following hardware detectors and have not provided your own model file, a default model will be downloaded on first startup:

Detector	Model Downloaded	Source
Rockchip RKNN	RKNN detection model	GitHub
Hailo 8 / 8L	YOLOv6n (.hef)	Hailo Model Zoo (AWS S3)
AXERA AXEngine	Detection model	HuggingFace

:::note

The default CPU, EdgeTPU, and OpenVINO object detection models are bundled into the Docker image and do not require any download at runtime.

:::

Preventing Model Downloads

If you have already downloaded all required models and want to prevent Frigate from attempting any outbound connections to HuggingFace or the Transformers library, set the following environment variables on your Frigate container:

environment:
  HF_HUB_OFFLINE: "1"
  TRANSFORMERS_OFFLINE: "1"

:::warning

Setting these variables without having the correct model files already cached in /config/model_cache/ will cause failures. Only use these after a successful initial setup with internet access.

:::

Mirror Support

If your Frigate instance has restricted internet access, you can point model downloads at internal mirrors using environment variables:

Environment Variable	Default	Used By
HF_ENDPOINT	https://huggingface.co	Semantic search, Sherpa-ONNX, AXEngine models
GITHUB_ENDPOINT	https://github.com	Face recognition, LPR, RKNN models
GITHUB_RAW_ENDPOINT	https://raw.githubusercontent.com	Bird classification
TF_KERAS_MOBILENET_V2_WEIGHTS_URL	Unset (Keras uses its own default)	Custom classification training

Optional Cloud Services

These features connect to external services during normal operation and require internet whenever they are active.

Frigate+

When a Frigate+ API key is configured, Frigate communicates with https://api.frigate.video to download models, upload snapshots for training, submit annotations, and report false positives. Remove the API key to disable all Frigate+ network activity.

See Frigate+ for details.

Generative AI

When a Generative AI provider is configured, Frigate sends images and prompts to the configured provider for event descriptions, chat, and camera monitoring. Available providers:

Provider	Internet Required
OpenAI	Yes, connects to OpenAI API (or custom base URL)
Google Gemini	Yes, connects to Google Generative AI API
Azure OpenAI	Yes, connects to your Azure endpoint
Ollama	Depends: typically local (localhost:11434), but can be remote
llama.cpp	No, runs entirely locally

Disable Generative AI by removing the genai configuration from your cameras. See Generative AI for details.

Version Check

Frigate checks GitHub for the latest release version on startup by querying https://api.github.com. This can be disabled:

telemetry:
  version_check: false

Push Notifications

When notifications are enabled and users have registered for push notifications in the web UI, Frigate sends push messages through the browser vendor's push service (e.g., Google FCM, Mozilla autopush). This requires internet access from the Frigate server to these push endpoints.

MQTT

If an MQTT broker is configured, Frigate maintains a connection to the broker's host and port. This is typically a local network connection, but will require internet if you use a cloud-hosted MQTT broker.

DeepStack / CodeProject.AI

When using the DeepStack detector plugin, Frigate sends images to the configured API endpoint for inference. This is typically local but depends on where the service is hosted.

WebRTC (STUN)

For WebRTC live streaming, Frigate uses STUN for NAT traversal:

• go2rtc defaults to a local STUN listener (stun:8555), no internet required.
• The web UI's WebRTC player includes a fallback to Google's public STUN server (stun:stun.l.google.com:19302), which requires internet.

Home Assistant Supervisor

When running as a Home Assistant App, the go2rtc startup script queries the local Supervisor API (http://supervisor/) to discover the host IP address and WebRTC port. This is a local network call to the Home Assistant host, not an internet connection.

What Does NOT Require Internet

• Object detection: CPU, EdgeTPU, OpenVINO, and other bundled detector models are included in the Docker image.
• Recording and playback: All video is stored and served locally.
• Live streaming: Camera streams are pulled over your local network. MSE and HLS streaming work without any external connections.
• The web interface: Fully self-contained with no external fonts, scripts, analytics, or CDN dependencies. All translations are bundled locally.
• Custom classification inference: After training, custom models run entirely locally.
• Audio detection: The YAMNet audio classification model is bundled in the Docker image.

Running Frigate Offline

To run Frigate in an air-gapped or offline environment:

1. Pre-download models: Start Frigate with internet access once with all desired features enabled. Models will be cached in /config/model_cache/.
2. Pre-download the training base weights: If you plan to train custom classification models, set TF_KERAS_MOBILENET_V2_WEIGHTS_URL before training, then run one training job while online. Without this variable the base weights are cached outside /config/ and are lost whenever the container is recreated, so a later training run will fail offline. If the machine never has internet access, copy the weights in manually as described below.
3. Disable version check: Set telemetry.version_check: false in your configuration.
4. Block outbound model requests: Set the HF_HUB_OFFLINE=1 and TRANSFORMERS_OFFLINE=1 environment variables to prevent HuggingFace and Transformers from attempting any network requests.
5. Avoid cloud features: Do not configure Frigate+, Generative AI providers that require internet, or cloud MQTT brokers.
6. Use local model mirrors: If limited internet is available, set the HF_ENDPOINT, GITHUB_ENDPOINT, GITHUB_RAW_ENDPOINT, and TF_KERAS_MOBILENET_V2_WEIGHTS_URL environment variables to point to local mirrors.

After these steps, Frigate will operate with no outbound internet connections.

Manually Copying the Training Base Weights

On a machine with internet access, download the weights:

curl -L -o mobilenet_v2_weights.h5 \
  "https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_0.35_224_no_top.h5"

Copy the file into your Frigate config volume as /config/model_cache/MobileNet/mobilenet_v2_weights.h5, keeping that exact filename, then set the environment variable TF_KERAS_MOBILENET_V2_WEIGHTS_URL in your Docker compose file to the URL above and restart Frigate.

The variable must be set even though the URL is never contacted. If it is unset, Frigate ignores the copied file and asks Keras to download the weights instead.