Computer vision · API / SDK

Viam Vision Service

Viam

Return detections, classifications or point-cloud objects from camera data.

Official documentation Download development spec

VIAM / DEVELOPER FIELD GUIDE

Choose an interface. Define a verifiable result.

Company or project context, ten technical entry points and a practical analysis of every reference.

2026-10-08 · Integration not tested

Company / project overview

Original summary of official company or project statements; use the source for the full original page.

Viam · About
Origins	Viam states it was founded in 2020 by MongoDB co-founder Eliot Horowitz.
Positioning	A software platform for building, deploying and managing robotics applications and fleets.
Company footprint	The company identifies New York City as its headquarters and robotics-lab location, with an international team.
Our fit assessment	A candidate for connecting inspection cameras, model services and fleet data; actual models, processing location and quality depend on configuration.

Complete official About page ↗

About reference — TA analysis
Audience	Buyers, partners and product owners shortlisting an AI provider.
Our assessment	Use positioning and company history for initial fit. Obtain project-specific deployment, support and commercial terms separately.

Official About and Python SDK references read on 2026-10-08. The main Vision guide could not be retrieved, so this guide uses the published SDK contract; verify compatibility with your installed SDK/runtime/module versions.

Top 10 technical entry points

Ten documented interfaces, operations or tools selected by integration task; not an official ranking or ten separate SDKs.

Choose by the work you need to complete
Interface	Purpose and audience
01 · RobotClient connectionPython client	Connect to a machine and discover its named resources.Edge / robotics backend engineer
02 · Camera acquisitionCamera API	Retrieve named images and capture metadata from a configured camera.Camera integrator / image pipeline
03 · Vision capabilitiesCapability query	Query supported vision operations.Integration architect
04 · Image detectionsVision operation	Return labels, scores and boxes for an image.Inspection UI developer
05 · Image classificationsVision operation	Return requested image classifications.Visual triage / ML integrator
06 · Combined camera captureVision operation	Request images and selected vision outputs together.Live visualisation developer
07 · MLModel tensor inferenceModel-service API	Read model metadata and pass named tensors for inference.ML deployment engineer
08 · ViamImage media adapterImage representation	Represent image bytes, MIME type and dimensions.Media / backend engineer
09 · DataClient retrievalCloud data API	Filter and paginate stored binary data and metadata.Data engineering / fleet analytics
10 · Custom resource moduleRuntime extension	Run custom resources as a module service.Edge platform / custom model developer

Reference analysis

Capabilities summarize official documentation. Constraints and proposed tests are our engineering assessment.

Python client

RobotClient connection

RobotClient connection · TA
Target audience	Edge / robotics backend engineer
Documented capability	Connect to a machine and discover its named resources.
Input → output	Machine address and credentials → resource connection
Execution environment	Client-to-machine communication via Viam runtime.
Our decision constraint	The right credential can still target the wrong machine; retain machine identity.
Our suggested validation	Verify resource names, disconnected behavior and connection cleanup.

Official reference · RobotClient connection ↗

Camera API

Camera acquisition

Camera acquisition · TA
Target audience	Camera integrator / image pipeline
Documented capability	Retrieve named images and capture metadata from a configured camera.
Input → output	Camera source selection → images and metadata
Execution environment	Configured camera driver and Viam runtime.
Our decision constraint	Multiple images can represent different imagers, not a temporal video sequence.
Our suggested validation	Validate source identity, timestamp, resolution and capture failures.

Official reference · Camera acquisition ↗

Capability query

Vision capabilities

Vision capabilities · TA
Target audience	Integration architect
Documented capability	Query supported vision operations.
Input → output	Service → capability flags
Execution environment	Configured service.
Our decision constraint	Do not enable a UI action just because a method exists in the SDK.
Our suggested validation	Use a classifier-only fixture and verify detection is unavailable.

Official reference · Vision capabilities ↗

Vision operation

Image detections

Image detections · TA
Target audience	Inspection UI developer
Documented capability	Return labels, scores and boxes for an image.
Input → output	Image → detections
Execution environment	Configured detector.
Our decision constraint	Our adapter must choose pixel or normalized units explicitly.
Our suggested validation	Check frame identity, box bounds and absence of unintended actuations.

Official reference · Image detections ↗

Vision operation

Image classifications

Image classifications · TA
Target audience	Visual triage / ML integrator
Documented capability	Return requested image classifications.
Input → output	Image and count → classes and scores
Execution environment	Configured classifier.
Our decision constraint	A class result alone cannot locate a defect or justify machine control.
Our suggested validation	Compare known categories and keep unfamiliar samples for review.

Official reference · Image classifications ↗

Vision operation

Combined camera capture

Combined camera capture · TA
Target audience	Live visualisation developer
Documented capability	Request images and selected vision outputs together.
Input → output	Camera and return flags → optional result fields
Execution environment	Configured camera/service.
Our decision constraint	Preserve unrequested null fields separately from requested empty arrays.
Our suggested validation	For every frame verify requested flags and matching overlay data.

Official reference · Combined camera capture ↗

Model-service API

MLModel tensor inference

MLModel tensor inference · TA
Target audience	ML deployment engineer
Documented capability	Read model metadata and pass named tensors for inference.
Input → output	Input tensor map → output tensor map
Execution environment	Selected ML model service implementation.
Our decision constraint	Shape, dtype, channel order and normalization must match model metadata.
Our suggested validation	Use a fixed tensor fixture and reject a deliberately wrong shape before rollout.

Official reference · MLModel tensor inference ↗

Image representation

ViamImage media adapter

ViamImage media adapter · TA
Target audience	Media / backend engineer
Documented capability	Represent image bytes, MIME type and dimensions.
Input → output	Encoded bytes and MIME → ViamImage
Execution environment	Python media representation.
Our decision constraint	A declared MIME type does not validate corrupted bytes or color order.
Our suggested validation	Decode a known image and compare dimensions and orientation before detection.

Official reference · ViamImage media adapter ↗

Cloud data API

DataClient retrieval

DataClient retrieval · TA
Target audience	Data engineering / fleet analytics
Documented capability	Filter and paginate stored binary data and metadata.
Input → output	Bounded filter and cursor → records and next cursor
Execution environment	Viam cloud data access; distinct from direct camera inference.
Our decision constraint	Empty filters can be broad; downloads and metadata-only reads have different cost and exposure.
Our suggested validation	Start with machine/time filters and metadata-only; verify pagination has no skipped records.

Official reference · DataClient retrieval ↗

Runtime extension

Custom resource module

Custom resource module · TA
Target audience	Edge platform / custom model developer
Documented capability	Run custom resources as a module service.
Input → output	Resource implementation → registered runtime service
Execution environment	Module process beside the Viam runtime.
Our decision constraint	A loaded process is not proof that hardware or weights are ready.
Our suggested validation	Exercise startup readiness, missing weights, reconfiguration and clean shutdown.

Official reference · Custom resource module ↗

Viam Python SDK

Viam Python SDK · Supporting reference analysis
TA	Platform engineer: installation, runtime and connection prerequisites.
Our validation advice	Pin SDK/runtime/module versions and check target OS transport support; SDK installation alone does not configure cameras or models.

Official reference · Viam Python SDK ↗

Primary developer documentation

Primary developer documentation · Supporting reference analysis
TA	Engineers choosing the supported API and installed version.
Our validation advice	Match the operation and version to the specific references above before implementation. The illustrative output is an internal application contract.

Official reference · Primary developer documentation ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Illustrative camera-inspection result only; no connection, image capture, inference or physical action was performed.

Illustrative contract · no API call or model execution · not measured provider output

Known marked frame

Expected behavior — illustrative, not executed
Input	A 640×480 fixture with a declared service and frame ID.
Expected result	ok; one bounded box and matching frame_ref.
Acceptance	No cross-frame overlay or implicit unit conversion.

Valid empty detection

Expected behavior — illustrative, not executed
Input	Detector succeeds on a no-target fixture.
Expected result	ok; detections=[]; unrequested classifications=null.
Acceptance	Empty remains distinct from not requested and unavailable.

Camera offline

Expected behavior — illustrative, not executed
Input	Configured camera cannot deliver a frame.
Expected result	error; data=null; camera_unavailable.
Acceptance	No stale frame silently treated as current success.

Wrong capability

Expected behavior — illustrative, not executed
Input	Request detections from a classification-only service.
Expected result	error; data=null; unsupported_capability.
Acceptance	Validate capabilities before scheduling repeated requests.

Map the expected result to your application

Before implementation identify the machine, camera, vision service, model revision and permitted data path. This JSON is an internal expected envelope, not Viam’s native response. Coordinate and confidence values are invented fixtures.

Expected output JSON — illustrative, not measured · ViamVision-expected-results.json

{
  "schema_version": "1.0.0",
  "provider": "Viam",
  "status": "ok",
  "example": true,
  "contract_origin": "Smart Tools illustrative internal contract; not a provider response",
  "input": {
    "machine_ref": "example-cell-A",
    "camera_ref": "example-camera-1",
    "service_ref": "example-detector",
    "frame_ref": "example-frame-101",
    "image_size_pixels": [
      640,
      480
    ],
    "requested": [
      "image",
      "detections"
    ]
  },
  "data": {
    "frame_ref": "example-frame-101",
    "detections": [
      {
        "label": "surface_mark",
        "score": 0.88,
        "box_xyxy_pixels": [
          64,
          48,
          192,
          144
        ]
      }
    ],
    "classifications": null,
    "actuation_requested": false
  },
  "error": null
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
Input requirements	Require authorized machine access, valid camera/service names, supported detection capability and a decodable frame.
Expected success	Return detections with frame identity and explicit coordinate units; preserve the configured model revision separately.
Expected empty	Requested detections=[] is a valid empty result; classifications=null means not requested in this contract.
Expected failure	Camera offline, unsupported capability, bad credentials or deadline failure return status=error and data=null.
Acceptance	For a 640×480 fixture validate box bounds, frame correlation and the distinction among empty, unrequested and failed results.
Limitations	No measured accuracy or latency. A surface-mark label is not a certified defect, and this contract sends no actuation command.
Data and runtime	Inspect module implementation to establish where inference happens; data-cloud capture/sync is a separate configuration decision.

Related route to assess: Roboflow

Development assessment

Camera perception adapter

Development concept · integration not tested

Provider capabilities above are based on official documentation or repositories. The proposed product, inputs, deliverable and acceptance criteria below are our development assessment.

Integration pilot

Validate runtime, schemas or hardware together before estimating a deployable product.

Proposed inputs: A small authorized image dataset, task definition and reference annotations.
Proposed deliverable: A reviewable result with image references, labels or annotation state; keep original files.
Acceptance criterion: Compare the supported operation against a labeled sample; report errors and missing results separately.
Dependencies: Dataset access, image rights and a supported model or annotation project.

Development sequence

Confirm access to Viam Vision Service, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Camera perception adapter”.
Normalize the result with source, time and explicit error state; keep the provider response for review.
Run the acceptance criterion before estimating rollout effort or committing a customer deliverable.

How to validate demand

Record product views, documentation clicks, specification downloads and contextual hub clicks. These are event counts, not unique people or completed integrations.

This feasibility assessment uses implementation conditions. No traffic-based rank or delivery-time promise is assigned.

Viam Vision Service

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

Viam Python SDK

Primary developer documentation

Expected results before implementation

Known marked frame

Valid empty detection

Camera offline

Wrong capability

Map the expected result to your application

Camera perception adapter

Development sequence

How to validate demand

Related products