DEV Community: Gianfrancesco

OPC UA in PHP without learning OPC UA - the 4.4.0 ecosystem ships AI Skills

Gianfrancesco — Thu, 04 Jun 2026 13:21:24 +0000

OPC UA in PHP - without learning OPC UA

A while back I shared a pure-PHP OPC UA ecosystem that lets a web app talk to factory-floor PLCs, CNC machines, SCADA systems and IoT sensors without C++ SDKs, gateways, or sidecar proxies. Just Composer and ext-openssl.

It just reached v4.4.0 - the biggest release so far. There's a lot of new protocol surface (aggregates, history writes, file transfer, three new transports - I'll cover them). But here's the thing I actually want to tell you about:

You no longer need to learn any of it.

Every package now ships an AI Skill. Point your coding assistant at one repo, describe what you want in plain English, and it writes correct OPC UA code - the right APIs, the right security model, the right patterns - without you knowing how OPC UA works or how the ecosystem is laid out.

Let me start there, then show what's under the hood for when you're curious.

The point: you don't have to be an OPC UA expert

OPC UA is deep. The spec runs to a dozen multi-hundred-page Parts. There are NodeIds, secure channels, sessions, subscriptions, monitored items, companion specifications, three transport mappings, a publish/subscribe model with pre-shared group keys... Learning enough to write correct code used to be a real investment.

And LLMs don't help much on their own here: ask a generic assistant to "read a tag from my PLC over OPC UA in PHP" and it will happily hallucinate method names, miss the security model, and reinvent patterns that don't exist. It has never seen these libraries.

That's exactly what an Agent Skill fixes. A skill is a SKILL.md file - frontmatter that tells the model when it's relevant, plus a body and references/ that tell it how to use the package correctly: the API surface, the idioms, the security model, the testing approach, the common pitfalls.

Every package in the ecosystem now ships one under .ai/skills/<package>/, and they're all mirrored into a single auto-synced repo: php-opcua/ai-skills.

So your assistant can learn the whole ecosystem from one place - and you can stay at the level of "what do I want to happen."

From plain English to correct code

With the skills installed, this is the actual workflow. You write:

"Connect to opc.https://plant.local:443/UA/ through our corporate proxy and read the boiler temperature tag."

...and your assistant produces working code that uses the right transport, knows TLS is the secure channel (so OPC UA security stays None), and routes the proxy through the HTTP client - none of which you had to know:

$transport = new HttpsTransport(
    httpClient: new CurlHttpClient(
        verifyTls: true,
        extraCurlOptions: [CURLOPT_PROXY => 'http://proxy.corp:3128'],
    ),
    encoding:    new BinaryHttpsEncoding(),
    endpointUrl: 'opc.https://plant.local:443/UA/',
);

$client = (new ClientBuilder())
    ->setSecurityPolicy(SecurityPolicy::None)   // TLS is the secure channel
    ->setSecurityMode(SecurityMode::None)
    ->setTransport($transport)
    ->connect('opc.https://plant.local:443/UA/');

echo $client->read('ns=2;s=Boiler/Temperature')->getValue();

Or "subscribe to the PubSub multicast group 239.0.0.1 and print every field", or "accept a reverse connection from our edge gateway and browse it" - same deal. You describe the outcome; the skill supplies the how.

Install it in one command

If you're on Laravel, Boost v2 pulls skills straight from a GitHub repo and syncs them across every AI agent it manages:

php artisan boost:add-skill php-opcua/ai-skills --list             # see what's available
php artisan boost:add-skill php-opcua/ai-skills --skill opcua-client
php artisan boost:add-skill php-opcua/ai-skills --all              # or grab everything

Using Claude Code? These are Anthropic Agent Skills - nothing to convert:

git clone https://github.com/php-opcua/ai-skills.git
cp -r ai-skills/skills/opcua-client ~/.claude/skills/     # personal, every project
# or .claude/skills/ to commit it with your repo

Claude Code auto-activates a skill when your task matches its description. Cursor, Windsurf, Copilot work too - drop the SKILL.md into their rules/instructions folder.

Take only the skills for the packages you use - each is self-contained. That's the whole onboarding.

...and if you are curious, here's what's new in 4.4.0

You don't need this section to be productive. But if you like knowing what your AI is driving, here's the release.

The ecosystem, briefly

Package	Role
`opcua-client`	The core - pure-PHP client: read, write, browse, call, subscribe, history
`opcua-cli`	Terminal companion - browse/read/write/watch, all with `--json`
`opcua-client-nodeset`	Pre-generated PHP types for OPC Foundation companion specs
`opcua-session-manager`	Keep sessions alive across requests via a ReactPHP daemon
`laravel-opcua` / `symfony-opcua`	Framework integrations

Core: aggregates, history writes, file transfer

AggregateModule computes Interpolate / Minimum / Maximum / Average / Count from a raw DataValue buffer - pair it with historyAggregate() to fetch + bucket in one call.
HistoryUpdate - nine new methods for Insert / Replace / Update / Remove of historical data and events. History is no longer read-only.
FileTransferModule wraps the OPC UA File Transfer service set (Part 5) into typed openFile / readFile / writeFile / closeFile calls, with chunked reads for large files.
A pluggable transport layer (ClientTransportInterface + ClientBuilder::setTransport()) - the quiet headline that made the three extensions below possible. Plus a small DataValue::getType() accessor so you can read a value's type without the deprecated getVariant() hop.

Three new transports

OPC UA isn't only opc.tcp://. v4.4.0 brings three more mappings as opt-in extensions:

opcua-client-ext-reverse-connect (Part 6 7.1.2.3) - the server dials you. For edge gateways and PLCs behind NAT/firewall that can't accept inbound connections but can dial out. Your app listens, validates the announced ServerUri against a fail-secure whitelist, then proceeds with the normal handshake.
opcua-client-ext-transport-https (Part 6 7.4) - opc.https://: one HTTPS POST per UA message, TLS as the secure channel. For getting through proxies and firewalls that block opc.tcp://. Binary encoding is production-ready; JSON ships as a reference.
opcua-client-ext-transport-pubsub (Part 14) - a PubSub subscriber: UADP and JSON over UDP (unicast or multicast), pre-shared group-key security, optional Security Key Service. A different runtime model, ideal for high-rate telemetry.

composer require php-opcua/opcua-client
# add only the transports you need:
composer require php-opcua/opcua-client-ext-reverse-connect
composer require php-opcua/opcua-client-ext-transport-https
composer require php-opcua/opcua-client-ext-transport-pubsub

Try it

Code & docs: https://github.com/php-opcua
AI Skills (start here): https://github.com/php-opcua/ai-skills
Docs site: https://www.php-opcua.com

Everything is pure PHP, MIT-licensed, and tested against the OPC Foundation's UA-.NETStandard reference server.

The best part? You can install the skills, describe what you need, and ship a working industrial integration this afternoon - without reading a single page of the OPC UA spec. If you build something with it (or your AI does), I'd love to hear about it.

Industry 4.0, meet composer require.

OPC UA in PHP without learning OPC UA - the 4.4.0 ecosystem ships AI Skills

Gianfrancesco — Thu, 04 Jun 2026 13:21:24 +0000

OPC UA in PHP - without learning OPC UA

You no longer need to learn any of it.

Let me start there, then show what's under the hood for when you're curious.

The point: you don't have to be an OPC UA expert

Every package in the ecosystem now ships one under .ai/skills/<package>/, and they're all mirrored into a single auto-synced repo: php-opcua/ai-skills.

So your assistant can learn the whole ecosystem from one place - and you can stay at the level of "what do I want to happen."

From plain English to correct code

With the skills installed, this is the actual workflow. You write:

"Connect to opc.https://plant.local:443/UA/ through our corporate proxy and read the boiler temperature tag."

$transport = new HttpsTransport(
    httpClient: new CurlHttpClient(
        verifyTls: true,
        extraCurlOptions: [CURLOPT_PROXY => 'http://proxy.corp:3128'],
    ),
    encoding:    new BinaryHttpsEncoding(),
    endpointUrl: 'opc.https://plant.local:443/UA/',
);

$client = (new ClientBuilder())
    ->setSecurityPolicy(SecurityPolicy::None)   // TLS is the secure channel
    ->setSecurityMode(SecurityMode::None)
    ->setTransport($transport)
    ->connect('opc.https://plant.local:443/UA/');

echo $client->read('ns=2;s=Boiler/Temperature')->getValue();

Install it in one command

If you're on Laravel, Boost v2 pulls skills straight from a GitHub repo and syncs them across every AI agent it manages:

php artisan boost:add-skill php-opcua/ai-skills --list             # see what's available
php artisan boost:add-skill php-opcua/ai-skills --skill opcua-client
php artisan boost:add-skill php-opcua/ai-skills --all              # or grab everything

Using Claude Code? These are Anthropic Agent Skills - nothing to convert:

git clone https://github.com/php-opcua/ai-skills.git
cp -r ai-skills/skills/opcua-client ~/.claude/skills/     # personal, every project
# or .claude/skills/ to commit it with your repo

Claude Code auto-activates a skill when your task matches its description. Cursor, Windsurf, Copilot work too - drop the SKILL.md into their rules/instructions folder.

Take only the skills for the packages you use - each is self-contained. That's the whole onboarding.

...and if you are curious, here's what's new in 4.4.0

You don't need this section to be productive. But if you like knowing what your AI is driving, here's the release.

The ecosystem, briefly

Package	Role
`opcua-client`	The core - pure-PHP client: read, write, browse, call, subscribe, history
`opcua-cli`	Terminal companion - browse/read/write/watch, all with `--json`
`opcua-client-nodeset`	Pre-generated PHP types for OPC Foundation companion specs
`opcua-session-manager`	Keep sessions alive across requests via a ReactPHP daemon
`laravel-opcua` / `symfony-opcua`	Framework integrations

Core: aggregates, history writes, file transfer

AggregateModule computes Interpolate / Minimum / Maximum / Average / Count from a raw DataValue buffer - pair it with historyAggregate() to fetch + bucket in one call.
HistoryUpdate - nine new methods for Insert / Replace / Update / Remove of historical data and events. History is no longer read-only.
FileTransferModule wraps the OPC UA File Transfer service set (Part 5) into typed openFile / readFile / writeFile / closeFile calls, with chunked reads for large files.
A pluggable transport layer (ClientTransportInterface + ClientBuilder::setTransport()) - the quiet headline that made the three extensions below possible. Plus a small DataValue::getType() accessor so you can read a value's type without the deprecated getVariant() hop.

Three new transports

OPC UA isn't only opc.tcp://. v4.4.0 brings three more mappings as opt-in extensions:

opcua-client-ext-reverse-connect (Part 6 7.1.2.3) - the server dials you. For edge gateways and PLCs behind NAT/firewall that can't accept inbound connections but can dial out. Your app listens, validates the announced ServerUri against a fail-secure whitelist, then proceeds with the normal handshake.
opcua-client-ext-transport-https (Part 6 7.4) - opc.https://: one HTTPS POST per UA message, TLS as the secure channel. For getting through proxies and firewalls that block opc.tcp://. Binary encoding is production-ready; JSON ships as a reference.
opcua-client-ext-transport-pubsub (Part 14) - a PubSub subscriber: UADP and JSON over UDP (unicast or multicast), pre-shared group-key security, optional Security Key Service. A different runtime model, ideal for high-rate telemetry.

composer require php-opcua/opcua-client
# add only the transports you need:
composer require php-opcua/opcua-client-ext-reverse-connect
composer require php-opcua/opcua-client-ext-transport-https
composer require php-opcua/opcua-client-ext-transport-pubsub

Try it

Code & docs: https://github.com/php-opcua
AI Skills (start here): https://github.com/php-opcua/ai-skills
Docs site: https://www.php-opcua.com

Everything is pure PHP, MIT-licensed, and tested against the OPC Foundation's UA-.NETStandard reference server.

Industry 4.0, meet composer require.

Who Says PHP Isn't Good Enough for OPC UA?

Gianfrancesco — Tue, 28 Apr 2026 09:42:40 +0000

"PHP? For OPC UA? Come on."

If you've ever tried to connect a PHP application to a PLC, a SCADA system, or any industrial device, you've probably heard that line. Maybe you said it yourself, opening a browser and searching for a library that didn't exist.

That time is over.

The Historical Gap

OPC UA is the standard protocol for industrial automation. Motors, sensors, historians, SCADA systems, PLCs — the entire Industry 4.0 world speaks OPC UA. It's the OPC Foundation standard: battle-tested, secure, feature-rich. It is, essentially, the TCP/IP of the manufacturing industry.

And yet, for years, PHP was left out.

These were your options:

1. An HTTP-to-OPC-UA gateway
Spin up a separate process (Python, Node.js, a C++ binary), expose a REST API, and have PHP act as the HTTP client. Result: a more complex infrastructure, added latency, one more point of failure, and a second language to maintain in parallel.

2. Compiled C/C++ extensions
Some PHP libraries wrap C implementations via FFI or native extensions. But compiling .so files for every PHP version, on every server, in every CI pipeline is an operational nightmare. And if your shared host doesn't support that extension? Dead stop.

3. Shell out to other languages
Calling a Python or Node.js process from PHP. Fragile. Slow. Hard to debug. And again: two stacks, two teams, two deployments.

4. Commercial Windows-only libraries
COM bridges, proprietary solutions, Windows-dependent. Let's not even go there.

The practical result? Anyone running an ERP in Laravel, a dashboard in Symfony, or even just a PHP API that needed to read a temperature from a Siemens S7 — had to face this reality: PHP wasn't "industrial enough."

Where php-opcua Comes From

The project was born out of a real need. Gianfrancesco Aurecchia, its creator and maintainer, had a PHP application for monitoring a production line. He needed to connect it to Siemens PLCs via OPC UA. Every available option was ugly, expensive, or both.

Instead of working around the problem, he built the solution.

The result — today — is an ecosystem of 7 packages, 147,000 lines of PHP, 2,649 tests, 5,204 assertions, and zero runtime dependencies beyond ext-openssl. An open-source project that implements the full OPC UA binary protocol natively in PHP.

The Ecosystem: Package by Package

1. `opcua-client` — The Core

This is the core package. It implements the entire OPC UA binary protocol stack in pure PHP:

TCP transport and binary encoding/decoding
Secure channel with asymmetric and symmetric encryption
Session management
All major OPC UA services: browse, read, write, method call, subscriptions, history

composer require php-opcua/opcua-client

use PhpOpcua\Client\ClientBuilder;

$client = ClientBuilder::create()
    ->connect('opc.tcp://192.168.1.100:4840');

$temp = $client->read('ns=2;s=Temperature');
echo $temp->getValue(); // 23.5

Three lines. No config files, no XML, no gateway.

10 security policies, from None up to Aes256_Sha256_RsaPss and the new ECC policies (nistP256, nistP384, brainpoolP256r1, brainpoolP384r1). Anonymous, username/password, and X.509 authentication. Persistent trust store with TOFU support.

2. `opcua-session-manager` — The Answer to PHP's Stateless Model

This was the biggest objection. OPC UA requires a persistent session: the initial handshake costs 50–200ms and must be repeated on every connection. PHP's request/response model destroys all state at the end of each request.

The answer is the Session Manager: a long-lived ReactPHP daemon that keeps OPC UA sessions alive in memory, communicating with PHP processes over a Unix socket. The handshake happens once. Every subsequent request reuses the existing session — reducing per-request overhead from ~150ms to ~5ms.

composer require php-opcua/opcua-session-manager

# Start the daemon
php bin/opcua-session-manager

use PhpOpcua\SessionManager\Client\ManagedClient;

// Same interface as the direct client
$client = new ManagedClient();
$client->connect('opc.tcp://localhost:4840');

$value = $client->read('i=2259');

ManagedClient implements the same OpcUaClientInterface as the direct client. Change one line, keep all your code. In production, the daemon runs under systemd or supervisord.

3. `laravel-opcua` — Laravel-Native

composer require php-opcua/laravel-opcua

Service Provider, Facade, Artisan commands, configuration via config/opcua.php. Named connections like database config. Subscriptions that become Laravel Events. Logging with Laravel's logger. Caching with Redis. Testing with MockClient.

use PhpOpcua\LaravelOpcua\Facades\Opcua;

// Read from the default connection
$temperature = Opcua::read('ns=2;s=Temperature');

// Switch to a different PLC on the fly
$level = Opcua::connection('tank-plc')
    ->read('ns=2;s=FillLevel');

The OpcuaManager automatically checks whether the Session Manager daemon is running: if the Unix socket exists, traffic routes through the daemon for session persistence; otherwise it builds a direct client. Zero code changes to switch between development and production.

4. `symfony-opcua` — The Symfony Bundle

composer require php-opcua/symfony-opcua

Dependency injection, semantic YAML configuration, autowiring of OpcUaClientInterface, a console command for the daemon, automatic Monolog integration, automatic PSR-16 cache pool injection, and 47 PSR-14 events dispatched through Symfony's event system.

# config/packages/php_opcua_symfony_opcua.yaml
php_opcua_symfony_opcua:
    connections:
        default:
            endpoint: '%env(OPCUA_ENDPOINT)%'

use PhpOpcua\SymfonyOpcua\OpcuaManager;

class PlcController
{
    public function status(OpcuaManager $opcua): Response
    {
        $client = $opcua->connect();
        $value  = $client->read('i=2259');
        return $this->json(['status' => $value->getValue()]);
    }
}

5. `opcua-client-nodeset` — 51 Companion Specs, Zero Manual Codecs

The OPC Foundation publishes dozens of "companion specifications": standardized data models for Robotics, Machinery, MachineTool, ISA-95, CNC, MTConnect, and many more. Decoding these structures normally requires writing custom codecs by hand.

opcua-client-nodeset ships 807 pre-generated PHP files from 51 companion specs. Enumerations as PHP BackedEnum, structures as typed DTOs with full IDE autocomplete.

composer require php-opcua/opcua-client-nodeset

use PhpOpcua\Nodeset\Robotics\RoboticsRegistrar;
use PhpOpcua\Nodeset\Robotics\Enums\OperationalModeEnumeration;

$client = ClientBuilder::create()
    ->loadGeneratedTypes(new RoboticsRegistrar())
    ->connect('opc.tcp://192.168.1.100:4840');

$mode = $client->read(RoboticsNodeIds::OperationalMode)->getValue();
// OperationalModeEnumeration::MANUAL_REDUCED_SPEED — not a raw integer

6. `opcua-cli` — Explore Without Writing Code

composer require php-opcua/opcua-cli

opcua-cli browse    opc.tcp://192.168.1.10:4840 /Objects
opcua-cli read      opc.tcp://192.168.1.10:4840 "ns=2;i=1001"
opcua-cli watch     opc.tcp://192.168.1.10:4840 "ns=2;s=Temperature"
opcua-cli endpoints opc.tcp://192.168.1.10:4840
opcua-cli trust     opc.tcp://server:4840
opcua-cli generate:nodeset MySpec.NodeSet2.xml

Address space browsing, node read/write, real-time monitoring, endpoint discovery, trust store management, and PHP class generation from custom NodeSet2.xml files. Full security support, JSON output, debug logging.

7. `uanetstandard-test-suite` — CI Without Compromise

A Docker environment with 10 pre-configured OPC UA servers based on UA-.NETStandard (the OPC Foundation's reference implementation), covering all security policies, all data types, events, and historical data. The opcua-client test suite runs against real servers, not mocks.

./vendor/bin/pest                                          # everything
./vendor/bin/pest tests/Unit/                              # unit only
./vendor/bin/pest tests/Integration/ --group=integration   # integration only

CI runs on PHP 8.2, 8.3, 8.4, and 8.5 via GitHub Actions.

Ecosystem by the Numbers


Lines of PHP	147,000
Tests	2,649
Assertions	5,204
Packages	7
Security policies	10 (RSA + ECC)
Companion specs	51
Pre-generated types	807
C runtime dependencies	0
Supported PHP versions	8.2 / 8.3 / 8.4 / 8.5

The Architecture at a Glance

Your Application
  │
  ├── laravel-opcua  or  symfony-opcua    Framework integration
  │     │
  │     ├── opcua-session-manager         Persistent sessions (optional)
  │     │
  │     └── opcua-client                  Binary protocol, crypto, I/O
  │           │
  │           └── opcua-client-nodeset    Type definitions (optional)
  │
  └── opcua-cli                           Developer tooling

Each package has a single responsibility. You can use just opcua-client in a CLI script, or the entire stack in an enterprise Laravel application. The only dependency required everywhere is ext-openssl.

What You Can Build With It Today

Real-time dashboards — Read process variables from PLCs in Laravel, display charts, fire alerts: all in the same stack as your existing web application. No sidecar, no extra microservice.

SCADA-to-ERP integration — Read production counters via OPC UA and write them directly into your PHP-based ERP, MES, or inventory system. In an Eloquent model. Through a queue. With all the tools you already know.

IoT data collection — Use the Session Manager to maintain persistent connections to dozens of devices simultaneously. Collect sensor data, store it in your database, process it with Laravel queues or Symfony Messenger.

Automated OPC UA server testing — Use MockClient for unit tests and the Docker test suite for CI integration. Validate your OPC UA server implementation with a PHP test suite, without needing a separate desktop client.

Still not convinced?

Fine — words are cheap. Here's a complete, runnable example you can clone,
composer install, and watch reconnect itself when you yank the cable:

php-opcua/examples — iot-data-collection/only-core

A production-shaped IoT data collector built only on opcua-client:
a long-running daemon that subscribes to monitored items, a cron-style
one-shot for periodic batches, both wired to the same PSR-14 event bus.
Persistence, MQTT forwarding, alerting — all of it lives in a single
user-editable listeners.php you actually want to write.

It's ready for critical workloads — designed to bend, not break, where
downtime is genuinely unacceptable. Connection drops? Infinite reconnect
with a configurable backoff schedule. Server failover? Subscription
rebuilt, monitored items re-registered, listeners none the wiser. Listener
throws? Wrapped, metric incremented, daemon stays up.

The README walks you through customization, the performance envelope, and
a 6-hour worst-case timeline showing exactly what the scaffold survives
without operator intervention.

Clone it. Run it. Pull the cable. See for yourself.

Bonus: It's Already AI-Ready

There's one more thing worth highlighting — because in 2026 it makes a real difference.

Using a new library with an AI assistant — Cursor, Copilot, Claude — only works well if the AI actually knows the library. If it doesn't, it generates plausible-looking but wrong code: unsupported patterns, non-existent methods, broken configurations. You end up spending more time correcting the AI than you would have spent reading the docs.

php-opcua has addressed this problem explicitly.

Every package in the ecosystem ships three files designed specifically for AI model consumption:

File	Content
`llms.txt`	Structured summary: API, key patterns, core examples
`llms-full.txt`	Complete documentation in LLM-optimized format
`llms-skills.md`	Skill file for AI assistants with usage rules and patterns

Available for every package directly from the website:

https://www.php-opcua.com/llms/opcua-client/llms.txt
https://www.php-opcua.com/llms/opcua-client/llms-full.txt
https://www.php-opcua.com/llms/opcua-client/llms-skills.md

https://www.php-opcua.com/llms/laravel-opcua/llms.txt
https://www.php-opcua.com/llms/symfony-opcua/llms.txt
https://www.php-opcua.com/llms/opcua-session-manager/llms.txt
https://www.php-opcua.com/llms/opcua-cli/llms.txt

And a centralized index for the entire ecosystem:

https://www.php-opcua.com/llms.txt

What changes in practice? Point your AI assistant at llms-full.txt for the package you need, or load llms-skills.md as context, and from that moment the AI generates correct code: the right NodeId strings, the right fluent builders, the right typed DTOs, the right retry and security patterns. Zero tokens wasted correcting hallucinations about an API the model never had in its training data.

The library isn't just AI-compatible — it's AI-first by design.

Conclusion

The historical PHP gap for OPC UA still lives on in tutorials, forum threads, and industrial conference slides. But in practice, from 2026, it's no longer a real problem.

php-opcua is a mature, tested, documented, and actively maintained ecosystem. Zero C extensions. Zero gateways. Zero architectural compromises. The full OPC UA binary protocol, in pure PHP, with native integration for Laravel and Symfony.

Next time someone tells you "PHP isn't good enough for OPC UA", you have a concrete answer.

Resources:

OPC UA from PHP? Yes, with Zero C Extensions — Introducing php-opcua/opcua-client

Gianfrancesco — Tue, 28 Apr 2026 09:06:08 +0000

If you've ever tried to connect a PHP application to industrial machinery — a PLC, a SCADA system, a historian — you've probably hit a wall. The OPC UA standard is the lingua franca of industrial IoT, but most implementations assume you're writing in C++, Python, or .NET. PHP? Good luck finding anything that isn't a thin HTTP wrapper around a gateway you have to run separately.

That changes with php-opcua/opcua-client.

What Is OPC UA?

OPC UA (Unified Architecture) is an industrial communication standard developed by the OPC Foundation. It lets software clients talk to sensors, PLCs, SCADA systems, historians, and IoT devices over a standardized protocol — with built-in security, data typing, discovery, and more. It's the backbone of Industry 4.0 and IIoT architectures worldwide.

The protocol runs over TCP (binary encoding) and is notoriously complex to implement: it includes asymmetric and symmetric encryption, certificate management, session handling, subscriptions, historical queries, and a rich address space model.

Why a Pure PHP Implementation?

Most PHP projects that need OPC UA resort to one of:

An HTTP REST gateway (adds a sidecar process, latency, and a point of failure)
A COM bridge on Windows (commercial, not portable)
Shelling out to a Python or Node.js script

php-opcua/opcua-client is different. It implements the entire OPC UA binary protocol stack natively in PHP, with only ext-openssl as a runtime dependency. No FFI. No COM. No gateway. Just composer require and you're connecting to PLCs from your Laravel app.

Quick Start

composer require php-opcua/opcua-client

use PhpOpcua\Client\ClientBuilder;

$client = ClientBuilder::create()
    ->connect('opc.tcp://localhost:4840');

$status = $client->read('i=2259');
echo $status->getValue(); // 0 = Running

$client->disconnect();

Three lines. No config files, no XML, no service containers.

NodeId strings like 'i=2259', 'ns=2;i=1001', or 'ns=2;s=MyNode' are accepted everywhere. Invalid strings throw InvalidNodeIdException.

Core Features in Practice

Browse the Address Space

$refs = $client->browse('i=85'); // Objects folder

foreach ($refs as $ref) {
    echo "{$ref->displayName} ({$ref->nodeId})\n";
    // => Server (ns=0;i=2253)
    // => MyPLC (ns=2;i=1000)
}

Read Multiple Values in One Round-Trip

$results = $client->readMulti()
    ->node('i=2259')->value()
    ->node('ns=2;i=1001')->displayName()
    ->node('ns=2;s=Temperature')->value()
    ->execute();

foreach ($results as $dataValue) {
    echo $dataValue->getValue() . "\n";
}

The fluent builder auto-batches requests transparently — one TCP round-trip regardless of how many nodes you chain.

Write to a PLC

use PhpOpcua\Client\Types\BuiltinType;

// Auto-detect type (reads the node first, caches the result)
$client->write('ns=2;i=1001', 42);

// Explicit type
$client->write('ns=2;i=1001', 42, BuiltinType::Int32);

Subscribe to Real-Time Data Changes

$sub = $client->createSubscription(publishingInterval: 500.0);

$client->createMonitoredItems($sub->subscriptionId, [
    ['nodeId' => NodeId::numeric(2, 1001)],
]);

$response = $client->publish();
foreach ($response->notifications as $notif) {
    echo $notif['dataValue']->getValue() . "\n";
}

Call Methods on the Server

use PhpOpcua\Client\Types\Variant;

$result = $client->call(
    'i=2253',   // Server object
    'i=11492',  // GetMonitoredItems method
    [new Variant(BuiltinType::UInt32, 1)],
);

echo $result->statusCode;                   // 0 (Good)
print_r($result->outputArguments[0]->value); // [1001, 1002, ...]

Query Historical Data

$values = $client->historyReadRaw(
    'ns=2;i=1001',
    startTime: new DateTimeImmutable('-1 hour'),
    endTime: new DateTimeImmutable(),
);

foreach ($values as $dv) {
    echo "[{$dv->sourceTimestamp->format('H:i:s')}] {$dv->getValue()}\n";
}

Enterprise-Grade Security

The library supports 6 security policies, from None up to Aes256Sha256RsaPss, and three authentication modes: anonymous, username/password, and X.509 certificates.

use PhpOpcua\Client\Security\SecurityPolicy;
use PhpOpcua\Client\Security\SecurityMode;

$client = ClientBuilder::create()
    ->setSecurityPolicy(SecurityPolicy::Basic256Sha256)
    ->setSecurityMode(SecurityMode::SignAndEncrypt)
    ->setClientCertificate('/certs/client.pem', '/certs/client.key', '/certs/ca.pem')
    ->setUserCredentials('operator', 'secret')
    ->connect('opc.tcp://192.168.1.100:4840');

Omit setClientCertificate() and a self-signed cert is auto-generated in memory — perfect for development or servers with auto-accept enabled.

The library also ships a persistent trust store with Trust-On-First-Use (TOFU) support:

use PhpOpcua\Client\TrustStore\FileTrustStore;
use PhpOpcua\Client\TrustStore\TrustPolicy;

$client = ClientBuilder::create()
    ->setTrustStore(new FileTrustStore())      // ~/.opcua/trusted/
    ->setTrustPolicy(TrustPolicy::Fingerprint)
    ->connect('opc.tcp://192.168.1.100:4840');

Laravel Integration

If you're on Laravel, there's a dedicated package:

composer require php-opcua/laravel-opcua

It ships a service provider, a facade, and config scaffolding so you can inject OpcUaClient from the container and configure connections in config/opcua.php. Fully compatible with Laravel's PSR-3 logger and PSR-14 event dispatcher.

47 PSR-14 Events — Zero Overhead When Unused

The library fires granular events for every lifecycle moment: connection, session, data change, alarms, retries, cache hits, and more. Plug in any PSR-14 dispatcher to react to them:

use PhpOpcua\Client\Event\AlarmActivated;

class AlarmHandler {
    public function handleActivated(AlarmActivated $event): void {
        Log::critical("Alarm: {$event->sourceName} (severity: {$event->severity})");
    }
}

Without a dispatcher, the default NullEventDispatcher ensures zero overhead.

Testing Without a Real PLC

The library ships a MockClient that implements the same interface as the real client — no TCP connection required:

use PhpOpcua\Client\Testing\MockClient;
use PhpOpcua\Client\Types\DataValue;

$client = MockClient::create();

$client->onRead(function (NodeId $nodeId) {
    return DataValue::ofDouble(23.5);
});

$value = $client->read('ns=2;s=Temperature');
echo $value->getValue(); // 23.5

echo $client->callCount('read'); // 1

Register handlers for onRead(), onWrite(), onBrowse(), onCall(), and onResolveNodeId(). Track calls with getCalls(), callCount(), and resetCalls(). Your CI pipeline never needs a real OPC UA server.

The CLI Tool

A companion CLI package lets you explore OPC UA servers from the terminal:

composer require php-opcua/opcua-cli

# Browse the address space
opcua-cli browse opc.tcp://192.168.1.10:4840 /Objects

# Read a value
opcua-cli read opc.tcp://192.168.1.10:4840 "ns=2;i=1001"

# Watch a value in real time
opcua-cli watch opc.tcp://192.168.1.10:4840 "ns=2;i=1001"

# Discover endpoints
opcua-cli endpoints opc.tcp://192.168.1.10:4840

# Manage trusted server certificates
opcua-cli trust opc.tcp://server:4840

It also generates PHP type files from NodeSet2.xml companion specifications — useful when working with vendor-specific data models.

Pre-Built Companion Types

The ecosystem includes php-opcua/opcua-client-nodeset, which ships pre-generated PHP types for 51 OPC Foundation companion specifications — Robotics, Machinery, MachineTool, ISA-95, CNC, MTConnect, and more:

use PhpOpcua\Nodeset\Robotics\RoboticsRegistrar;
use PhpOpcua\Nodeset\Robotics\Enums\OperationalModeEnumeration;

$client = ClientBuilder::create()
    ->loadGeneratedTypes(new RoboticsRegistrar())
    ->connect('opc.tcp://192.168.1.100:4840');

// Enum values auto-cast to PHP BackedEnum — not raw ints
$mode = $client->read(RoboticsNodeIds::OperationalMode)->getValue();
// OperationalModeEnumeration::MANUAL_REDUCED_SPEED

Structured types return typed DTOs with IDE autocomplete — no more digging through arrays.

What About Long-Lived Connections?

PHP's request/response model doesn't naturally support persistent TCP connections. For continuous monitoring or subscription polling, the ecosystem provides php-opcua/opcua-session-manager — a ReactPHP daemon that keeps OPC UA sessions alive across short-lived PHP requests via Unix sockets. It's a separate package by design: bundling a ReactPHP daemon would break the zero-dependency philosophy of the core library.

Feature Summary

Feature	Status
Browse / Path resolution	✅
Read / Write (single & batch)	✅
Subscriptions & data change events	✅
Historical data (raw, processed, at-time)	✅
Method calls	✅
6 security policies (None → Aes256Sha256RsaPss)	✅
Anonymous / Username / X.509 auth	✅
PSR-3 logging, PSR-14 events, PSR-16 cache	✅
MockClient for testing	✅
Laravel service provider + facade	✅
CLI tool	✅
51 companion NodeSet types	✅
PHP 8.2 / 8.3 / 8.4 / 8.5	✅
Zero runtime deps (except ext-openssl)	✅
1290+ tests, 99%+ coverage	✅

Conclusion

php-opcua/opcua-client fills a real gap: industrial systems speak OPC UA, and PHP has always been left out of that conversation. This library brings the full protocol stack to PHP with production-grade security, a clean API, a MockClient for testing, and a growing ecosystem of companion packages.

If you're building anything in the IIoT or Industry 4.0 space with PHP — connecting Laravel to factory floor equipment, pulling data from historians, or monitoring production lines — this library is worth a look.

Links:

🌐 Website: php-opcua.com
📦 GitHub: github.com/php-opcua/opcua-client
📦 Packagist: packagist.org/packages/php-opcua/opcua-client
🛠️ CLI: github.com/php-opcua/opcua-cli
🏭 Laravel: github.com/php-opcua/laravel-opcua

DEV Community: Gianfrancesco

OPC UA in PHP without learning OPC UA - the 4.4.0 ecosystem ships AI Skills

OPC UA in PHP - without learning OPC UA

The point: you don't have to be an OPC UA expert

From plain English to correct code

Install it in one command

...and if you are curious, here's what's new in 4.4.0

The ecosystem, briefly

Core: aggregates, history writes, file transfer

Three new transports

Try it

OPC UA in PHP without learning OPC UA - the 4.4.0 ecosystem ships AI Skills

OPC UA in PHP - without learning OPC UA

The point: you don't have to be an OPC UA expert

From plain English to correct code

Install it in one command

...and if you are curious, here's what's new in 4.4.0

The ecosystem, briefly

Core: aggregates, history writes, file transfer

Three new transports

Try it

Who Says PHP Isn't Good Enough for OPC UA?

The Historical Gap

Where php-opcua Comes From

The Ecosystem: Package by Package

1. opcua-client — The Core

2. opcua-session-manager — The Answer to PHP's Stateless Model

3. laravel-opcua — Laravel-Native

4. symfony-opcua — The Symfony Bundle

5. opcua-client-nodeset — 51 Companion Specs, Zero Manual Codecs

6. opcua-cli — Explore Without Writing Code

7. uanetstandard-test-suite — CI Without Compromise

Ecosystem by the Numbers

The Architecture at a Glance

What You Can Build With It Today

Still not convinced?

Bonus: It's Already AI-Ready

Conclusion

OPC UA from PHP? Yes, with Zero C Extensions — Introducing php-opcua/opcua-client

What Is OPC UA?

Why a Pure PHP Implementation?

Quick Start

Core Features in Practice

Browse the Address Space

Read Multiple Values in One Round-Trip

Write to a PLC

Subscribe to Real-Time Data Changes

Call Methods on the Server

Query Historical Data

Enterprise-Grade Security

Laravel Integration

47 PSR-14 Events — Zero Overhead When Unused

Testing Without a Real PLC

The CLI Tool

Pre-Built Companion Types

What About Long-Lived Connections?

Feature Summary

Conclusion

1. `opcua-client` — The Core

2. `opcua-session-manager` — The Answer to PHP's Stateless Model

3. `laravel-opcua` — Laravel-Native

4. `symfony-opcua` — The Symfony Bundle

5. `opcua-client-nodeset` — 51 Companion Specs, Zero Manual Codecs

6. `opcua-cli` — Explore Without Writing Code

7. `uanetstandard-test-suite` — CI Without Compromise