Industrial IoT / SCADA · SDK / protocol

asyncua

FreeOpcUa

Integrate OPC UA systems with an asynchronous Python library.

Official documentation Download development spec

Repository and documentation introduction disagree on Python minimum versions. Current repository says Python >=3.10; pin a release and verify its package metadata. Deprecated security policies are not recommended.

FREEOPCUA / OPCUA-ASYNCIO / 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.

FreeOpcUa / opcua-asyncio · About
Project	opcua-asyncio is the FreeOpcUa asyncio-based OPC UA client/server library for Python. It offers high-level objects, lower-level protocol structures and a synchronous wrapper.
Developer fit	Useful for Python telemetry adapters, industrial test applications and custom OPC UA servers. The application owns event-loop behavior, trust configuration and data interpretation.

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 sources reviewed; no live API, inference or benchmark was run. Expected results are proposed internal contracts.

Top 10 technical entry points

Ten documented technical entry points selected by developer task; not ten separate SDKs or an official ranking.

Choose by the work you need to complete
Interface	Purpose and audience
01 · Async ClientAPI / SDK / developer guide	Connect sessions and access remote services.Python integration developers
02 · Async ServerAPI / SDK / developer guide	Host an OPC UA address space.Equipment simulator developers
03 · Node data accessAPI / SDK / developer guide	Read DataValue metadata or node values.Telemetry adapter engineers
04 · Subscription and handlersAPI / SDK / developer guide	Monitor data changes and events.Streaming telemetry developers
05 · Security policiesAPI / SDK / developer guide	Configure cryptographic policies and certificates.Secure OPC UA integrators
06 · Synchronous wrapperAPI / SDK / developer guide	Use a synchronous facade over async operations.Existing synchronous Python application teams
07 · High availability clientAPI / SDK / developer guide	Manage non-transparent server redundancy.Redundant server integrators
08 · UA types and status structuresAPI / SDK / developer guide	Represent OPC UA typed structures.Protocol adapter authors
09 · CLI toolsAPI / SDK / developer guide	Use command-line discovery, browse and data tools.Developers diagnosing OPC UA endpoints
10 · Minimal server tutorialAPI / SDK / developer guide	Create objects, variables and callable methods.Teams learning address-space construction

Reference analysis

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

API / SDK / developer guide

Async Client

Async Client · TA
Target audience	Python integration developers
Documented capability	Connect sessions and access remote services.
Input → output	Endpoint and credentials → client session/results.
Execution environment	Python asyncio.
Our decision constraint	Await operations and close sessions.
Our suggested validation	Verify endpoint security and connection failure handling.

Official reference · Async Client ↗

API / SDK / developer guide

Async Server

Async Server · TA
Target audience	Equipment simulator developers
Documented capability	Host an OPC UA address space.
Input → output	Endpoint/model configuration → running server.
Execution environment	Python asyncio process.
Our decision constraint	Default settings require deployment-specific review.
Our suggested validation	Check lifecycle cleanup and allowed user operations.

Official reference · Async Server ↗

API / SDK / developer guide

Node data access

Node data access · TA
Target audience	Telemetry adapter engineers
Documented capability	Read DataValue metadata or node values.
Input → output	NodeId → value/status/timestamps.
Execution environment	Client or server Node object.
Our decision constraint	Bad status can raise; value-only reads lose metadata.
Our suggested validation	Preserve quality and namespace identity.

Official reference · Node data access ↗

API / SDK / developer guide

Subscription and handlers

Subscription and handlers · TA
Target audience	Streaming telemetry developers
Documented capability	Monitor data changes and events.
Input → output	Nodes and handler → notifications.
Execution environment	Async subscription callbacks.
Our decision constraint	Do not block the event loop.
Our suggested validation	Separate silent healthy periods from disconnects.

Official reference · Subscription and handlers ↗

API / SDK / developer guide

Security policies

Security policies · TA
Target audience	Secure OPC UA integrators
Documented capability	Configure cryptographic policies and certificates.
Input → output	Policy/key/certificates → secured channel configuration.
Execution environment	Python crypto support.
Our decision constraint	Basic128Rsa15 and Basic256 are marked deprecated.
Our suggested validation	Reject untrusted certificates and incompatible policies.

Official reference · Security policies ↗

API / SDK / developer guide

Synchronous wrapper

Synchronous wrapper · TA
Target audience	Existing synchronous Python application teams
Documented capability	Use a synchronous facade over async operations.
Input → output	Blocking-style call → wrapped result.
Execution environment	Python sync wrapper.
Our decision constraint	Choose concurrency boundaries deliberately.
Our suggested validation	Measure blocking impact during later application tests.

Official reference · Synchronous wrapper ↗

API / SDK / developer guide

High availability client

High availability client · TA
Target audience	Redundant server integrators
Documented capability	Manage non-transparent server redundancy.
Input → output	HA mode and server URLs → selected serving client.
Execution environment	Async HA manager.
Our decision constraint	Servers need aligned NodeIds, address space, service-level logic and time.
Our suggested validation	Test failover data continuity; HA is not a zero-loss promise.

Official reference · High availability client ↗

API / SDK / developer guide

UA types and status structures

UA types and status structures · TA
Target audience	Protocol adapter authors
Documented capability	Represent OPC UA typed structures.
Input → output	Python/UA fields → NodeId, Variant or DataValue.
Execution environment	Python UA package.
Our decision constraint	Retain explicit types rather than JSON-only assumptions.
Our suggested validation	Validate integer ranges and namespace serialization.

Official reference · UA types and status structures ↗

API / SDK / developer guide

CLI tools

CLI tools · TA
Target audience	Developers diagnosing OPC UA endpoints
Documented capability	Use command-line discovery, browse and data tools.
Input → output	CLI arguments → diagnostic output.
Execution environment	Installed asyncua command-line environment.
Our decision constraint	Write/call tools can have equipment side effects.
Our suggested validation	Start with authorized read-only diagnostics.

Official reference · CLI tools ↗

API / SDK / developer guide

Minimal server tutorial

Minimal server tutorial · TA
Target audience	Teams learning address-space construction
Documented capability	Create objects, variables and callable methods.
Input → output	Namespace and sample model → tutorial server.
Execution environment	Async Python tutorial application.
Our decision constraint	A tutorial configuration is not a production deployment checklist.
Our suggested validation	Review variable write access and method arguments.

Official reference · Minimal server tutorial ↗

Documentation introduction

Documentation introduction · Supporting reference analysis
TA	Teams choosing Python support
Our validation advice	Intro still says Python 3.7+ while current repository says 3.10+; use the pinned package metadata as the installation authority.

Official reference · Documentation introduction ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Illustrative Python OPC UA adapter results; no endpoint connection, subscription or equipment write was performed.

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

Metadata-preserving read

Expected behavior — illustrative, not executed
Input	Example variable read via DataValue.
Expected result	Internal value=21.5 with type/status and nullable timestamps.
Acceptance	Do not label missing source timestamps as fresh telemetry.

Empty browse

Expected behavior — illustrative, not executed
Input	Successful browse with no matching children.
Expected result	Internal status=empty, children=[].
Acceptance	BadNodeId or connection failure must remain errors.

Bad quality read

Expected behavior — illustrative, not executed
Input	DataValue reports a bad status or read raises.
Expected result	Internal status=error with actual status/exception category.
Acceptance	Do not publish the last numeric value as healthy.

Subscription disconnect

Expected behavior — illustrative, not executed
Input	Connection is lost after monitored items were established.
Expected result	Internal status=disconnected and stale=true; last value retained separately.
Acceptance	Reconnect must revalidate session/subscriptions and avoid invented updates.

Map the expected result to your application

Map the actual SDK or service response into this proposed internal contract after integration. All IDs and values below are invented examples; no credentials or live requests are included.

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

{
  "schema_version": "1.0.0",
  "example": true,
  "provider": "FreeOpcUa / opcua-asyncio",
  "status": "ok",
  "input_id": "sample-001",
  "data": {
    "node_id": "ns=2;s=Example.Temperature",
    "value": 21.5,
    "variant_type": "Double",
    "status_code": "Good",
    "source_timestamp": null,
    "stale": false
  },
  "error": null,
  "verification": "illustrative-only;not-provider-response"
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
Result interpretation	Successful transport or execution does not establish model accuracy. Preserve valid empty results separately from operational failure.
Reproducibility	Record model, runtime, configuration and input identifiers; agree quality and latency criteria before representative tests. No measured performance is claimed.
Operation boundary	Illustrative Python OPC UA adapter results; no endpoint connection, subscription or equipment write was performed.

Development assessment

Python equipment tag monitor

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 test device or simulator, a tag map and documented units.
Proposed deliverable: Timestamped device values with freshness, unit and connection state.
Acceptance criterion: Verify scaling and timestamps against the source; a disconnected device must not appear healthy.
Dependencies: A gateway or service account, an equipment schema and access to a test environment.

Integration condition

Development sequence

Confirm access to asyncua, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Python equipment tag monitor”.
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.

asyncua

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

Documentation introduction

Expected results before implementation

Metadata-preserving read

Empty browse

Bad quality read

Subscription disconnect

Map the expected result to your application

Python equipment tag monitor

Integration condition

Development sequence

How to validate demand

Related products