A beginner's guide to the Depth-Anything-V3-Mono model by Vufinder on Replicate

This is a simplified guide to an AI model called Depth-Anything-V3-Mono maintained by Vufinder. If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter.

Overview

depth-anything-v3-mono is a monocular relative depth estimation model built on Depth Anything 3 (DA3), created by vufinder. It predicts spatially consistent depth from a single RGB image using a plain transformer backbone (vanilla DINO encoder) with a unified depth-ray representation, eliminating the need for architectural specialization or complex multi-task learning. The model is part of the DA3 monocular series, specifically optimized for high-quality relative depth estimation by directly predicting depth rather than disparity. This approach delivers superior geometric accuracy compared to disparity-based alternatives. The model is trained exclusively on public academic datasets and represents state-of-the-art performance for monocular depth estimation tasks, outperforming Depth Anything 2.

Best use cases

Robotics perception and navigation — The model produces high-quality relative depth maps essential for robot motion planning, obstacle avoidance, and grasp detection. Monocular depth works well here because robots often integrate depth with other sensors (IMU, odometry) for metric localization, so relative depth is the limiting factor.

3D reconstruction from monocular video — For applications processing video sequences frame-by-frame without pre-estimated camera poses, this model generates geometrically consistent depth maps that fuse reliably into point clouds or mesh models. The direct depth prediction (rather than disparity) maintains better spatial coherence across dynamic scenes.

Depth-guided image segmentation and understanding — Computer vision pipelines that need depth context for semantic scene parsing, instance segmentation, or salient object detection benefit from the model's fast relative depth inference. The output depth maps integrate naturally as an additional channel in segmentation networks.

Mobile and edge deployment scenarios — When metric scale is not required but relative geometry is critical, this model's monocular design avoids the computational overhead of multi-view processing. A single image produces immediate depth output without requiring image pairs or sequences.

AR/VR foreground-background separation — Virtual reality applications can use the monocular depth maps to separate subjects from backgrounds for occlusion handling and depth-aware rendering, without needing stereo camera rigs or structured light sensors.

Limitations

The model outputs relative depth, not metric depth. It cannot determine the true scale of scenes without additional calibration or reference measurements. If your application requires real-world metric scale (centimeters, meters), use depth-anything-v3-metric instead or apply post-hoc scaling.

Monocular depth estimation inherently struggles with ambiguous geometry—thin structures, transparent surfaces, reflective materials, and scenes with strong repetitive patterns often produce unreliable depth. The model also performs worse on extreme lighting conditions (very dark, overexposed) and out-of-distribution scenes not well-represented in academic training data.

Input images must be in JPG, JPEG, PNG, or WEBP format. Maximum spatial dimension defaults to 504 pixels (36 patches × 14 pixels per patch), though this can be customized via the num_patches parameter. Processing resolution can be adjusted to default, match_input, or custom, but higher resolutions increase memory requirements and latency.

The model produces relative depth arrays as float32 tensors. Confidence maps are also returned, but the model does not natively output metric depth, 3D Gaussian splatting predictions, or pose estimates—those capabilities belong to the larger DA3 any-view models.

Inference speed depends on image resolution and hardware; no specific latency guarantees are published for the Replicate endpoint, so test with your typical inputs beforehand.

How it compares

vs. depth-anything-v2: The v3-mono model uses direct depth prediction instead of disparity estimation, yielding superior geometric accuracy for monocular tasks. Choose v3-mono if you need the highest relative depth quality and have already committed to monocular input; choose v2 if you need faster inference or have an existing pipeline optimized for disparity-based depth. v2 remains valuable for legacy integrations but v3-mono is the newer, more geometrically accurate approach.

vs. depth-anything: The original Depth Anything is heavier and optimized for robustness across diverse unlabeled data (62M+ images), while v3-mono is a specialized, lighter variant trained only on academic datasets. Use the original if handling extremely varied, in-the-wild imagery; use v3-mono for cleaner, well-curated inputs where relative depth quality matters more than dataset diversity.

vs. depth-anything-v3-metric: Both are part of the DA3 series, but v3-metric outputs metric depth (real-world scale) while v3-mono outputs relative depth. Choose v3-mono for speed and simplicity when metric scale is not needed; choose v3-metric when your application requires true measurements in centimeters or meters.

vs. ml-depth-pro (Apple's Depth Pro): Depth Pro is Apple's foundation model emphasizing metric depth and zero-shot generalization. v3-mono focuses on relative depth with academic training data. If you need metric depth, use Depth Pro; if you prioritize relative geometric consistency and have cleaner inputs, v3-mono often produces sharper, more locally accurate depth.

vs. map-anything: Map Anything performs universal feed-forward metric 3D reconstruction, likely from multiple views or video. v3-mono is single-image relative depth only. Use v3-mono for per-frame monocular depth; use Map Anything when you need full 3D scene reconstruction with metric scale from richer input.

Technical specifications

The model uses a vanilla DINO transformer encoder as its backbone without architectural specialization, paired with a DualDPT head for depth-ray prediction. It is trained on public academic datasets only (no proprietary or massive unlabeled collections) and achieves state-of-the-art monocular depth estimation performance, outperforming Depth Anything 2.

The unified depth-ray representation replaces multi-task learning complexity with a single prediction target, reducing model bloat while improving generalization. The model operates at a default processing resolution of 504 pixels (36 patches, 14 pixels per patch) but supports custom resolutions via the num_patches parameter. Input images are normalized and processed in batches.

Key parameters and options:

• Input formats: JPG, JPEG, PNG, WEBP
• Default processing resolution: 504 pixels (36 patches × 14 px)
• Custom resolution: Configurable via num_patches parameter (integer)
• Output data types: Depth as float32 arrays, confidence as float32, processed images as uint8
• Base64 encoding: Supported for JSON output via to_base64 toggle (default: true)
• Output format options: JSON, NPZ, or other formats via output_format parameter
• Alpha blending: For images with transparency, choose between mean (blend onto ImageNet mean RGB) or keep (preserve original values)
• Training data: Exclusively public academic datasets (no unlabeled web-scale data)
• Architecture: Plain transformer + depth-ray prediction (no specialized heads for multi-task learning)

No quantization options are mentioned; the model runs in full precision on Replicate. No explicit VRAM or latency requirements are published.

Model inputs and outputs

Inputs

• images (array of strings, URI format): Input image paths. Accepts JPG, JPEG, PNG, WEBP files. Required.
• to_base64 (boolean, default: true): Whether to encode output arrays as base64 strings with shape and dtype metadata in JSON responses.
• num_patches (integer, default: 36): Maximum spatial dimension in number of patches (14 px per patch). Only applies if processing_resolution is set to custom.
• return_depth (boolean, default: true): Whether to include depth images in the output.
• output_format (enum, default: "json"): Format of prediction results. Options likely include json, npz, or other formats.
• keys_to_exclude (string, default: ""): Comma-separated list of output keys to exclude from JSON responses (e.g., "extrinsics,intrinsics").
• processing_resolution (enum, default: "default"): Spatial dimension strategy. Options: default (504 px), match_input (computed across batch), custom (set manually via num_patches).
• alpha_blend_onto (enum, default: "keep"): Blending mode for transparent images. Options: keep (preserve original) or mean (blend onto ImageNet mean RGB).

Outputs

• depth (float32 array, shape [N, H, W]): Predicted relative depth for each input image.
• conf (float32 array, shape [N, H, W]): Confidence map for each depth prediction.
• processed_images (uint8 array, shape [N, H, W, 3]): Preprocessed input images used by the model (useful for alignment verification).
• Output format: Determined by output_format parameter (JSON with optional base64 encoding, or NPZ binary).
• Excluded keys: Any keys listed in keys_to_exclude are omitted from the response.

Getting started

import replicate

# Submit a prediction with a single image
output = replicate.run(
    "vufinder/depth-anything-v3-mono:2dad523efc4f21f134480ef1878e7a145c1d761d156d558392002196703f2e45",
    input={
        "images": [
            "https://example.com/image1.jpg",
            "https://example.com/image2.png"
        ],
        "to_base64": True,
        "return_depth": True,
        "output_format": "json",
        "processing_resolution": "default",
        "alpha_blend_onto": "keep"
    }
)

# output contains depth arrays, confidence maps, and processed images
print(output)

If you want to customize the processing resolution:

import replicate

output = replicate.run(
    "vufinder/depth-anything-v3-mono:2dad523efc4f21f134480ef1878e7a145c1d761d156d558392002196703f2e45",
    input={
        "images": ["https://example.com/high_res_image.jpg"],
        "processing_resolution": "custom",
        "num_patches": 48,  # Higher resolution (672 px)
        "to_base64": False,
        "output_format": "json"
    }
)

Frequently asked questions

Q: Does this model output metric depth or relative depth?

A: It outputs relative depth only. If you need metric depth (real-world scale in centimeters or meters), use depth-anything-v3-metric instead. Relative depth is useful for geometry-aware applications (robotics, segmentation, 3D reconstruction with external pose) but cannot determine absolute scale.

Q: How does v3-mono compare to Depth Anything 2?

A: The v3 model uses direct depth prediction instead of disparity estimation, delivering superior geometric accuracy. It also simplifies the architecture by eliminating multi-task learning complexity. Choose v3-mono for the highest relative depth quality; v2 remains faster and more established in legacy pipelines.

Q: What image formats and resolutions does the model accept?

A: It accepts JPG, JPEG, PNG, and WEBP files. Default processing resolution is 504 pixels (36 patches × 14 px per patch). You can customize resolution via the num_patches parameter when processing_resolution is set to custom. Higher resolutions increase memory and latency.

Q: Can I process multiple images in a single API call?

A: Yes, the images input is an array. You can submit multiple image URLs in one request, and the model returns depth, confidence, and processed images for all inputs in batch.

Q: What license applies to this model?

A: The model is released under CC BY-NC 4.0, which permits non-commercial use with attribution. Commercial applications require a separate license agreement.

Q: How does the model perform on transparent surfaces, glass, or thin structures?

A: Monocular depth estimation inherently struggles with ambiguous geometry—transparent materials, reflections, and thin structures often produce unreliable depth. Confidence maps help identify uncertain regions, but the output may not be trustworthy in these cases. Test on your specific use case.

Q: Is this model still actively maintained?

A: Yes, the Depth Anything 3 series is actively developed by ByteDance Seed. The latest version was published February 5, 2026, and includes the DA3-Streaming feature for long-video processing on limited GPU memory.

Q: What is the difference between processing_resolution options?

A: default uses 504 pixels (36 patches). match_input adapts resolution across the batch based on input dimensions (useful for variable-size image sets). custom lets you specify num_patches manually for fine-grained control. Higher resolutions improve detail but increase latency and memory use.

Click here to read the full guide to Depth-Anything-V3-Mono