Offline Deployment | StereoLabs

The ZED SDK downloads some data from the StereoLabs servers the first time it needs it. On a system without an internet connection, such as a robot operating in the field or a machine on a secured industrial network, these downloads fail and the application cannot open the camera or enable the requested module.

This page explains how to retrieve this data on a machine with internet access and copy it to the target system, so that the target system works without an internet connection.

What the ZED SDK Downloads at Runtime

Data	When it is downloaded	Linux folder	Windows folder
Camera calibration file (`SN<serial_number>.conf`)	The first time a camera is opened, if no local file and no valid EEPROM data are available	`/usr/local/zed/settings/`	`C:\ProgramData\StereoLabs\settings\`
AI models (`.model2`, `.model`)	The first time a feature that requires them is used: `NEURAL` depth modes, Object Detection, Body Tracking, and other AI-based features	`/usr/local/zed/resources/`	`C:\ProgramData\StereoLabs\resources\`

Before their first use, AI models must also be optimized for the GPU of the system. The optimization does not require an internet connection once the model files are present, but it takes time: optimizing all the available models takes about 40 minutes on an NVIDIA® Jetson AGX Thor™ and about one hour on an NVIDIA® Jetson AGX Orin™.

Calibration Files

Option 1: Download the Calibration File Manually

On any machine with internet access, open https://calib.stereolabs.com/?SN=<serial_number>, replacing <serial_number> with the serial number printed on the camera label. The browser downloads the SN<serial_number>.conf file.
Copy the file into the settings folder of the target system (see the table above). Create the folder if it does not exist.
Repeat for each camera that will be used on the target system.

If your application stores the calibration files in a different location, set InitParameters::optional_settings_path to the folder that contains them.

A calibration file only depends on the camera serial number. The same file can be copied to any system the camera will be connected to, regardless of the platform or of the ZED SDK version.

Option 2: Use the Calibration Stored on the Camera EEPROM

All cameras produced after May 2026, except the ZED Mini, store the factory calibration on their internal EEPROM. With ZED SDK v5.3 or newer, these cameras can be opened without a local calibration file and without an internet connection: the ZED SDK reads the EEPROM and generates the calibration file in the settings folder automatically.

Older cameras can be provisioned once: connect the camera to a machine with internet access and write the factory calibration to its EEPROM with the ZED Explorer --dc (--download_calibration) option:

/usr/local/zed/tools/ZED_Explorer --dc <serial_number>

The camera can then be moved to the target system.

A calibration file in the settings folder always takes precedence over the EEPROM data. See Camera Calibration for the full selection order.

AI Models

The resources folder contains two kinds of files:

Downloaded models (*.model2 files, and *.model files depending on the model and on the ZED SDK version): generic files that do not depend on the GPU or on the platform. They can be copied to any system that runs the same ZED SDK version.
Optimized models (hidden files named .<model_name>_optimized-<signature>, plus .*_timing_cache files): generated from the downloaded models for one specific hardware and software configuration.

The models are prepared with the following ZED Diagnostic options:

Option	Action
`-aid`	Downloads all the AI models, including the `NEURAL` depth models, without optimizing them
`-aio`	Optimizes all the AI models, including the `NEURAL` depth models, and downloads the missing ones
`-ais X`	Downloads, if missing, and optimizes the `sl::DETECTION_MODEL` `X` (integer)
`-nrlo`, `-nrlo_plus`, `-nrlo_light`, `-nrlo_all`	Downloads, if missing, and optimizes the `NEURAL`, `NEURAL PLUS`, `NEURAL LIGHT`, or all the `NEURAL` depth models

Add -c to run ZED Diagnostic in command line mode, without a GUI. Optimizing only the models used by your application, with -ais X and -nrlo*, is much faster than optimizing all of them with -aio.

Choose the option that matches your deployment.

Option 1: Target Identical to a Reference System

Use this option to deploy a fleet of identical units, for example several robots with the same NVIDIA® Jetson™ module. The optimized models are copied as-is, so the target system starts immediately without any optimization step.

The reference system and the target system must be identical: same GPU or Jetson module, same NVIDIA® driver or JetPack version, same CUDA and TensorRT versions, and same ZED SDK version. If any of these differ, the copied optimized models are ignored and the ZED SDK optimizes the models again on first use.

On the reference system, connected to the internet, download and optimize the models used by your application:

# All the AI models: NEURAL depth modes, Object Detection, Body Tracking, ...
/usr/local/zed/tools/ZED_Diagnostic -c -aio

Copy the whole resources folder, including the hidden files, to the target system. For example, on Linux:
```
rsync -a /usr/local/zed/resources/ <user>@<target_ip>:/usr/local/zed/resources/
```

Option 2: Target Different from the Download System

Use this option when the system with internet access has a different GPU, platform, or software stack than the target system, for example a development PC preparing the models for an NVIDIA® Jetson™ device.

On the system with internet access, install the same ZED SDK version as the target system, then download the models without optimizing them:
```
# All the AI models: NEURAL depth modes, Object Detection, Body Tracking, ...
/usr/local/zed/tools/ZED_Diagnostic -c -aid
```
For an application that only uses depth sensing, -nrlo_all also downloads all the NEURAL depth models, but it optimizes them for the local GPU as well. This takes much longer than a download and is unnecessary, since these optimized models cannot be reused on the target system: prefer -aid.
Copy only the downloaded model files to the resources folder of the target system. The *.model* pattern does not match the hidden optimized files. For example, on Linux:
```
rsync -a /usr/local/zed/resources/*.model* <user>@<target_ip>:/usr/local/zed/resources/
```
On the target system, optimize the models before running your application, with -aio or, to save time, with -ais X and -nrlo* for the models your application uses. No internet connection is required, since the model files are already present:
```
# All the AI models: NEURAL depth modes, Object Detection, Body Tracking, ...
/usr/local/zed/tools/ZED_Diagnostic -c -aio
```
If you skip this step, the ZED SDK optimizes each model automatically the first time it is used, which delays the start of your application.

On Windows, use C:\Program Files (x86)\ZED SDK\tools\ZED Diagnostic.exe with the same options, and the C:\ProgramData\StereoLabs\resources\ folder.

The user running the ZED SDK application on the target system must be able to read the copied files and to write to the resources folder, where the ZED SDK stores the optimized models.

Docker Containers

A container’s filesystem is reset every time the container is recreated: the calibration files and AI models downloaded or optimized inside it are lost, and an offline system cannot download them again. Prepare the settings and resources folders on the host as described above, then bind-mount them into the container:

-v /usr/local/zed/settings/:/usr/local/zed/settings/ \
-v /usr/local/zed/resources/:/usr/local/zed/resources/ \

Alternatively, copy the two folders into the image at build time. In this case, include the optimized models only if the image runs on systems identical to the one that optimized them (see Option 1).

See Cache AI models and calibration files across containers for more details when several containers share the same host.

Checklist Before Deployment

The ZED SDK version on the target system is the same as the one used to download the AI models.
The SN<serial_number>.conf file of every camera is in the settings folder, or every camera has its calibration stored on the EEPROM.
The downloaded model files of every AI model used by the application are in the resources folder.
The AI models have been optimized on the target system, or copied from an identical reference system.
The application has been tested on the target system with the network disconnected, and no download or optimization message is printed when the camera is opened and the modules are enabled.

Troubleshooting

When the data the ZED SDK needs is missing and no internet connection is available, the following errors are reported:

Error	Cause	Solution
`CALIBRATION FILE NOT AVAILABLE` when opening the camera	No `SN<serial_number>.conf` file in the `settings` folder and no valid calibration on the camera EEPROM	Copy the calibration file, see Calibration Files
`CORRUPTED SDK INSTALLATION` when opening the camera with a `NEURAL` depth mode, with `Model download error` and `NEURAL CORRUPTED MODEL` in the log	The model file of the selected depth mode is missing from the `resources` folder	Copy the downloaded model files, see AI Models
`Please wait while the AI model is being optimized for your graphics card` when the application starts	The optimized models are missing, or were copied from a system that is not identical	Optimize the models on the target system, see Option 2