Industrial IoT / SCADA · SDK / protocol

PyModbus

PyModbus Project

Use Python clients, servers and simulators for Modbus communication.

Official documentation Download development spec

PYMODBUS / 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.

PyModbus · About
Project	PyModbus is a Python implementation of Modbus with client, server and simulator capabilities.
Version boundary	The catalog latest URL currently displays unreleased4.0 development docs. This selection uses stable3.15 documentation and requires pinned versions.

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 provider API or inference was run; results are illustrative internal contracts.

Top 10 technical entry points

Ten documented technical entry points selected for implementation decisions, not ten independent SDKs or an official ranking.

Choose by the work you need to complete
Interface	Purpose and audience
01 · ModbusTcpClientAPI / SDK / developer guide	Synchronous TCP client.Polling developers
02 · AsyncModbusTcpClientAPI / SDK / developer guide	Awaitable TCP operations.Async integrators
03 · ModbusSerialClientAPI / SDK / developer guide	Serial-port Modbus client.Serial integrators
04 · read_holding_registersAPI / SDK / developer guide	Read holding registers.Register-map integrators
05 · convert_from_registersAPI / SDK / developer guide	Convert registers to typed values.Telemetry decoders
06 · Server APIAPI / SDK / developer guide	Serve a configured Modbus data context.Simulator developers
07 · Simulator entrypointAPI / SDK / developer guide	Configure virtual Modbus behavior.Integration QA
08 · Simulator data modelAPI / SDK / developer guide	Define virtual device data and register layout.Test-fixture authors
09 · ExceptionResponseAPI / SDK / developer guide	Represent a Modbus exception PDU.Error-handling developers
10 · API changesAPI / SDK / developer guide	Review breaking signature and data-model changes.Library maintainers

Reference analysis

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

API / SDK / developer guide

ModbusTcpClient

ModbusTcpClient · TA
Target audience	Polling developers
Documented capability	Synchronous TCP client.
Input → output	Request → Modbus response.
Execution environment	Pinned3.15; TCP device.
Our decision constraint	Calls need serialization.
Our suggested validation	Proposed gate: verify device map and cleanup.

Official reference · ModbusTcpClient ↗

API / SDK / developer guide

AsyncModbusTcpClient

AsyncModbusTcpClient · TA
Target audience	Async integrators
Documented capability	Awaitable TCP operations.
Input → output	Awaited request → response.
Execution environment	Single owning event loop.
Our decision constraint	Parallel calls require application control.
Our suggested validation	Proposed gate: verify cancellation and reconnection policy.

Official reference · AsyncModbusTcpClient ↗

API / SDK / developer guide

ModbusSerialClient

ModbusSerialClient · TA
Target audience	Serial integrators
Documented capability	Serial-port Modbus client.
Input → output	Serial request → response.
Execution environment	Serial extra; matching port settings.
Our decision constraint	Wrong framing prevents valid communication.
Our suggested validation	Proposed gate: confirm wiring and settings with the device owner.

Official reference · ModbusSerialClient ↗

API / SDK / developer guide

read_holding_registers

read_holding_registers · TA
Target audience	Register-map integrators
Documented capability	Read holding registers.
Input → output	Address/count/device_id → registers.
Execution environment	Correct target/register map.
Our decision constraint	Address numbering may differ from manuals.
Our suggested validation	Proposed gate: assert count before decoding.

Official reference · read_holding_registers ↗

API / SDK / developer guide

convert_from_registers

convert_from_registers · TA
Target audience	Telemetry decoders
Documented capability	Convert registers to typed values.
Input → output	Registers/type/word order → value.
Execution environment	Device-specific encoding.
Our decision constraint	Word order matters.
Our suggested validation	Proposed gate: compare known raw patterns and engineering units.

Official reference · convert_from_registers ↗

API / SDK / developer guide

Server API

Server API · TA
Target audience	Simulator developers
Documented capability	Serve a configured Modbus data context.
Input → output	Client request → server response from context.
Execution environment	3.x server API and selected transport.
Our decision constraint	Legacy datastores are scheduled for replacement in4.0.
Our suggested validation	Use isolated test bindings and validate start/stop lifecycle.

Official reference · Server API ↗

API / SDK / developer guide

Simulator entrypoint

Simulator entrypoint · TA
Target audience	Integration QA
Documented capability	Configure virtual Modbus behavior.
Input → output	Simulator settings → simulated requests/responses.
Execution environment	Simulator dependencies and explicit device configuration.
Our decision constraint	Simulation cannot establish physical-device compatibility.
Our suggested validation	Plan valid, illegal-address and timeout fixtures without real equipment.

Official reference · Simulator entrypoint ↗

API / SDK / developer guide

Simulator data model

Simulator data model · TA
Target audience	Test-fixture authors
Documented capability	Define virtual device data and register layout.
Input → output	Data model definitions → simulated register state.
Execution environment	Matching SimData/SimDevice API release.
Our decision constraint	Fixture design must match intended device semantics.
Our suggested validation	Record valid ranges and invalid-address boundaries.

Official reference · Simulator data model ↗

API / SDK / developer guide

ExceptionResponse

ExceptionResponse · TA
Target audience	Error-handling developers
Documented capability	Represent a Modbus exception PDU.
Input → output	Function and exception codes → protocol error response.
Execution environment	Version-matched response types.
Our decision constraint	Protocol exception is different from a valid measurement.
Our suggested validation	Retain codes and distinguish connection failures in application errors.

Official reference · ExceptionResponse ↗

API / SDK / developer guide

API changes

API changes · TA
Target audience	Library maintainers
Documented capability	Review breaking signature and data-model changes.
Input → output	Installed/target versions → migration actions.
Execution environment	Pinned release and matching examples.
Our decision constraint	3.10 replaced slave keywords and removed payload helpers.
Our suggested validation	Review every minor update; do not assume semantic-version compatibility.

Official reference · API changes ↗

Official documentation

Official documentation · Supporting reference analysis
TA	Developers and technical product owners
Our validation advice	Pin the release and follow the target-specific support requirements before implementation.

Official reference · Official documentation ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Illustrative register-read contract; no Modbus connection, simulator, polling or write was executed.

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

Decoded register

Expected behavior — illustrative, not executed
Input	Invented register235 using an explicitly invented scale0.1.
Expected result	23.5C only under that documented application mapping.
Acceptance	Real acceptance requires manufacturer register map, type, order and units.

No polling targets

Expected behavior — illustrative, not executed
Input	Application configuration contains zero enabled targets.
Expected result	skipped; no protocol request sent.
Acceptance	Do not issue count=0 to imitate an empty database query.

Protocol exception

Expected behavior — illustrative, not executed
Input	Requested register range is rejected by device.
Expected result	Protocol error with code; decoded value absent.
Acceptance	Do not convert exception payload into a sensor reading.

No response

Expected behavior — illustrative, not executed
Input	Device fails to respond within configured policy.
Expected result	Communication failure; no fresh value.
Acceptance	Preserve last-known timestamp separately and bound retries.

Map the expected result to your application

Map your actual runtime response into this proposed application contract. All values are invented examples; no credentials or live execution are included.

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

{
  "schema_version": "1.0.0",
  "example": true,
  "provider": "PyModbus",
  "status": "ok",
  "input_id": "sample-001",
  "data": {
    "device_id": 1,
    "address": 0,
    "registers": [
      235
    ],
    "decode_rule": "demo unsigned integer /10",
    "temperature_c": 23.5,
    "physical_validation": false
  },
  "error": null,
  "verification": "illustrative-only;not-provider-response"
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
State semantics	Valid empty results differ from errors. Pending work must not appear successful before completion.
Evidence	Record service and SDK versions, request identity, configuration and response mapping. No execution or performance was measured here.
Acceptance proposal	Agree numerical tolerances and workload targets before testing on representative authorized samples.

Development assessment

Read-only register 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.

Development sequence

Confirm access to PyModbus, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Read-only register 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.

PyModbus

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

Official documentation

Expected results before implementation

Decoded register

No polling targets

Protocol exception

No response

Map the expected result to your application

Read-only register monitor

Development sequence

How to validate demand

Related products