Stream

Sell the data your machine generates: signed, encrypted, and verifiable, with buyers paying for access to exactly what they need.

Stream is the data side of the machine economy. A machine signs the data it generates, encrypts whatever is sensitive, and sells access to it, so robots and devices earn from the one thing they produce constantly: machine data.

Where Scale lets a machine buy services and Monetize lets it sell its capacity, Stream lets it sell data. It signs every data package with the machine’s key, so a buyer can check which machine produced it. For packages signed with the SDK, the package verifier recovers the EIP-191 signer, accepts only address DIDs (did:peaq:0x<address>), and checks that the signature recovers to that address. Set the package DID to the address of the signing key: the decimal peaqID (did:peaq:<machine id>) that Activate issues does not pass that check. The ROS 2 Edge Agent signs its envelopes with Ed25519 instead, so verify those with the Edge Agent pipeline.

What ships

Component	Description
peaqOS Edge Agent	A persistent on-machine process, installed as a ROS 2 node, that signs, encrypts, and ships the data the machine generates. It signs with its own Ed25519 key, generated on first run, writes the machine DID from its identity_ref setting (did:peaq:0x<address>) into every manifest, and runs the signing pipeline automatically once configured.
Data Event Map	The policy file that controls what streams out: topic subscriptions, per-field rules (include, exclude, encrypt, anonymize), signing policy, and output destinations.
Signed data packages	An SDK data package carries the signing address as a DID (did:peaq:0x<address>), a timestamp, a schema version, and a sequence number, signed with the machine’s key (EIP-191). Anyone verifies it by recovering the signer from the signature and matching it to the address in the package DID. Edge Agent envelopes are signed with the agent’s Ed25519 key and checked against that key. Field rules run before signing, so protected fields never leave in the clear while the package stays verifiable.
Chunking + encryption	Data is grouped into bounded chunks, each encrypted under its own key and linked into a tamper-evident chain.
Data marketplace	Buyers verify signatures and hashes, pay over a transfer or x402 rail, and receive an access grant: the purchased chunk keys re-wrapped to their public key. The backend stores manifests and grants, never plaintext. The purchase and delivery calls ship in the SDKs, but no released orchestrator build serves the purchase routes yet, hosted at orchestration.peaq.xyz or self-hosted, so these calls return 404 today. See Distribution.
Distribution	Signed, encrypted chunks leave over the owner’s chosen vector: a direct machine-to-machine P2P transfer (peaqos-p2p), S3-compatible cloud storage, Walrus, or a direct API.

How it works

1. Install and configure. The Machine Owner installs the Edge Agent as a ROS 2 package and writes a Data Event Map: which topics to read, which fields to keep, drop, or encrypt, and where signed data goes.
2. Sign and encrypt. As data is captured, field rules run first, then the package is signed with the machine’s key and grouped into encrypted chunks.
3. List and sell. The owner lists chunks for sale. Buyers verify the machine’s signatures and chunk hashes before paying.
4. Grant and deliver. After payment, an access grant re-wraps the purchased chunk keys to the buyer’s key. The buyer decrypts only what they bought.

See Data streams for the full trust model.

Sell across chains

Buyers pay on the chain a listing quotes in. The transfer rail covers peaq, Base, and Solana, and the x402 rail covers signed pay-per-request authorizations. The sale record stays canonical on peaq. Broader omnichain settlement is rolling out; see the roadmap.

Build with Stream

Data streams (concept)

The trust model: signing, chunk chains, encryption, and buyer access grants.

Stream SDK reference

The stream module for JavaScript and Python.

Distribution & P2P delivery

Purchases, payment rails, and delivery: buyer access over S3, or encrypted chunks streamed machine-to-machine over P2P.

Stream Edge Agent (ROS 2)

Run the on-machine node that signs, encrypts, chunks, and streams your data.

peaqOS CLI: stream

Publish signed, encrypted chunks and grant buyer access from the terminal.

Roadmap

Where Stream sits and what ships next.

Related

• Activate
• Monetize
• Wallets (OWS)