peaqOS Stream Adds End-to-End Machine Data Distribution with P2P Delivery

Robots and machines running peaqOS can now distribute the data they produce directly to the buyers who pay for it. End-to-end: captured on the machine, protected by field-level privacy rules, signed with the machine’s identity, encrypted into verifiable chunk chains, sold over onchain rails, and delivered machine-to-buyer, over P2P or through storage-backed delivery when that fits better.

A buyer verifies a robotaxi dataset against the machine’s onchain identity before paying a single token. A drone streams encrypted lidar chunks straight to the training network that bought them: machine to machine, no storage hop in the middle. A warehouse robot’s sensor logs decrypt on the buyer’s own hardware, and only the chunks they paid for. Each runs on peaqOS Stream. Stream now delivers.

When Stream launched, it solved the trust problem. Any machine could sign its data at the source, encrypt what’s sensitive, and prove exactly which machine produced every frame. But trustworthy data still had to change hands, and that last mile ran through someone else’s infrastructure. Today it doesn’t have to. The rails for verifiable, peer-to-peer data delivery are live.

→ Build with Stream distribution → https://docs.peaq.xyz/peaqos/sdk-reference/stream-distribution

The Missing Mile of Machine Data

A single self-driving car already generates tens of terabytes of data a day, fuel for a physical AI market Barclays sizes at $500 billion to $1.4 trillion by 2035. Stream made that data verifiable: signed by the machine, checkable by anyone, owned by the operator.

What it couldn’t do yet was move it. A signed dataset still needed a way to reach whoever bought it, and the operator had two options. Move it over generic file transfer, with no proof of origin and no control once it leaves. Or build a bespoke pipeline for every single buyer, with storage, keys, and payments wired by hand.

With Stream’s new distribution layer, there’s a third option: the machine delivers the data itself, encrypted and verifiable, straight to whoever bought it.

Verified, Paid, Delivered

Every delivery runs through the same shape:

→ A buyer who verifies before buying. Every dataset is chunked, hashed, and committed through a Merkle root, tied to the machine’s DID and signed with its keys. The buyer checks the manifest against the machine’s peaqID before committing to the purchase. Provenance first, payment second.

→ A payment that gates delivery. The buyer pays for the purchase, the selling machine is notified the moment the payment verifies, and delivery only proceeds for a purchase that’s been paid. No payment, no keys.

→ A delivery only the buyer can open. The purchased chunk keys are wrapped to the buyer’s key alone: no re-encrypting the dataset, no exposing the plaintext. The encrypted chunks then travel over the peaqos-p2p transport, machine to machine, with no storage bucket in the middle. The buyer verifies every chunk’s signature, hash, and chain linking, then decrypts locally, on their own hardware.

That’s it. The seller never decrypts the data to sell it. The buyer only decrypts the chunks they paid for. Nothing in the middle ever holds the plaintext.

And because access is granted at the chunk level, a buyer can purchase an hour of lidar out of a month of driving, and decrypt exactly that hour. Pay-per-chunk, delivered machine-to-buyer, settled onchain.

P2P Moves the Data. Trust Travels With It.

The P2P channel is a transport, not a trust layer. And that’s the point. Trust doesn’t come from the pipe the data moves through. It comes from what’s attached to the data itself: the machine’s signature, the hashes, the manifests, and the chunk chain that makes any missing, reordered, or edited piece detectable. All of it is verified on the buyer’s side before a single chunk is decrypted. Delivery sessions are single-use, with replay protection built in.

So the data can take any path, peer to peer, storage-backed, across networks, and arrive exactly as trustworthy as it left the machine.

What Distribution Unlocks

For operators. Your machines’ data ships itself. Set the privacy policy, list the dataset, and the delivery runs on its own: payment verified, keys wrapped to the buyer, delivery straight from the machine. A revenue line without handing custody of your data to anyone along the way.

For data buyers and AI builders. You see proof before you pay. Every dataset carries the identity of the machine that made it and a Merkle root to check it against. And once you’ve paid, the data comes to you, decryptable by you alone. Trust the math, straight from the source.

For data markets and context providers. The delivery rails come built in. Platforms that normalize, package, or resell machine data are Stream’s natural counterparties: they plug into the purchase, payment, and delivery flow, receive encrypted chunks straight from the machines, and pass machine-verified provenance through to their own customers.

For the robots and machines themselves. They complete the full loop as data producers: produce, protect, price, deliver. What a machine senses is now something it can sell: signed with its identity, on rails the operator controls.

What’s Live on peaqOS Today

→ Activate. Every robot and machine onboarded with a peaqID, omnichain wallets, and a Machine NFT.

→ Qualify. Each one rated with a dynamic Machine Credit Rating.

→ Scale. Each one consuming services and Machine Money Markets through robotic.sh.

→ Stream. Each one turning its data into a signed, verifiable asset, and now delivering it, end-to-end.

Monetize, Verify, and Tokenize come next.

Plug Into Stream

Build with Stream distribution. Purchases, payment rails, and P2P delivery, available in the peaqOS SDKs for Python and JavaScript → https://docs.peaq.xyz/peaqos/sdk-reference/stream-distribution

Activate your machines. Onboard your robots and machines to peaqOS and put their data to work → https://app.peaq.xyz/os

Robots and machines sense, sign, and monetize. Now they deliver.

‍