AIOZ Stream Explained: Decentralized Video Infrastructure

AIOZ Stream is a video API that ingests, transcodes, stores and delivers your video on one decentralized network, the AIOZ DePIN. You upload a file or send a live RTMP feed, and we turn it into adaptive renditions served from the same nodes that store them.

TL;DR:

• For on-demand video, AIOZ Stream transcodes one upload into several renditions (H.264 up to 4K, H.265 up to 8K) and packages each as HLS or DASH.
• For live video, you send RTMP from OBS or PRISM Live Studio and viewers watch over HLS, with a Low Latency Mode (Beta) for interactive streams.
• Renditions are stored on the same network that delivers them, so there's no separate storage vendor and CDN to keep in sync.
• The player adapts quality to each viewer's connection, and QoE targets tell you whether playback went well.

Updated Oct 19, 2026: replaced the outdated "live streaming is not yet available" lines and FAQ with the documented live path (RTMP ingest, HLS playback, Low Latency Mode (Beta), statistics and multicast), added DASH output and a first API request, and tightened the text.

What happens between upload and playback?

Five things happen before anyone watches your video: ingest, transcoding, storage, delivery and quality monitoring. On most platforms, different vendors handle these stages and you stitch them together. On AIOZ Stream they run on one network, which changes how storage and delivery work in particular.

Ingest and transcoding: one file becomes many renditions

The file you upload isn't what your viewers receive. The media API transcodes it into renditions at different resolutions and bitrates, from 240p up to 4320p. A viewer on a phone over 4G and a viewer on a fiber-connected TV should never get the same file.

Codec choice follows the target device. H.264 decodes on almost every device from the last decade and goes up to 4K on AIOZ Stream. H.265 (HEVC) compresses the same picture into roughly 30 to 50% less data and goes up to 8K, but it needs newer hardware to decode efficiently. The docs add one Apple detail worth knowing: Safari and iOS play HEVC over HLS only in fMP4/CMAF segments, not in MPEG-TS.

Each rendition is cut into short segments and packaged as HLS (MPEG-TS or MP4 containers) or DASH (fMP4). Segments let the player switch renditions mid-stream, and they let your viewer jump to the middle of a long video without downloading everything before it. Transcoding takes time in proportion to the source length and the targets you pick, so the developer API treats it as an asynchronous job. Webhooks can tell you when a file arrives, when encoding starts and when it finishes.

How does adaptive bitrate pick a rendition?

Adaptive bitrate (ABR) streaming lets the player choose which rendition to request next, based on measured bandwidth and buffer health. A good ABR player also avoids overreacting. Switching resolution every few seconds because of a short network blip feels worse than holding a slightly lower but steady picture, so ABR logic usually watches trends across several segments. Our ABR explainer covers the algorithms in more depth.

Storage: renditions live on the network that delivers them

A traditional setup stores files in a data center and serves them from a separate CDN, so two systems have to agree on every file's status. AIOZ Stream stores renditions on the same network that delivers them. That's a structural choice, and it's why there's no storage vendor for you to reconcile with the delivery layer.

Spreading storage across independently operated nodes also removes the single data center as a point of failure. In exchange, you rely on the network's own redundancy rather than one company's infrastructure guarantees. On Oct 19, 2026, AIOZ's network page listed 329,387 DePIN nodes across the whole AIOZ Network, contributing storage, compute and delivery capacity. That figure covers the wider network, not a Stream-only subset. For how those nodes are organized and rewarded, see our AIOZ DePIN explainer.

Delivery: HTTP segments for on-demand video

On-demand playback uses plain HTTP segments, either HLS or DASH, and the API returns an hls_url and a dash_url for each video. Each segment sits at a fixed URL, so once a node has fetched it for one viewer, the next viewer nearby can get it without another trip to where it was first stored. That's the same caching any HTTP CDN relies on, spread across operator-run nodes instead of one company's edge servers. To see how HLS and DASH compare with WebRTC, RTMP and SRT, read our guide to the main video streaming protocols.

HTTP delivery trades a few seconds of startup for reach and simple caching. For on-demand video that's the right trade, since your viewers aren't watching the same second at the same time.

How does live streaming work on AIOZ Stream?

Live streaming is shipped and documented: you create a Stream Key in the dashboard, then point OBS Studio or PRISM Live Studio at the RTMP Server URL with that key. You can preconfigure a session with a title, resolutions, a thumbnail, extra destinations and a "save to archive" option. If you skip that step, AIOZ Stream creates the live entry automatically when valid credentials start streaming. For the concept behind it, our explainer on decentralized live streaming follows a broadcast from ingest to viewers through independently run nodes.

Viewers watch through an HLS playback URL, a player link or an embed code. In the dashboard player view, a Low Latency Mode (Beta) toggle reduces the delay for interactive broadcasts such as Q&A, auctions and gaming. The statistics endpoint reports frame rate and bitrate in and out, updated every 5 to 30 seconds. With the multicast endpoint, you can forward the same stream to platforms such as YouTube, Facebook and Twitch over RTMP.

What the docs don't cover yet: a published latency figure for either live mode, and any WebRTC ingest or playback path. If latency matters to you, measure it with the stopwatch method in our glass-to-glass latency guide, and see our LL-HLS explainer for how HTTP delivery gets down to a few seconds.

Quality monitoring: knowing whether playback went well

None of this helps if nobody checks the result, so the player reports startup time, rebuffer events and delivered bitrate, which also feed the next ABR decision. The QoE docs describe a composite view that weighs perceived quality against rebuffer and startup penalties, then adjusts for stability. A high average bitrate with frequent stalls scores worse than a steadier, more modest stream, which matches what frustrates viewers.

The docs also give starting targets: first frame in under about 2 seconds for short-form content, and a rebuffer ratio under about 0.5 to 1.0%. They suggest you watch the 95th percentile rather than the average, since a healthy average can hide a tail of bad sessions. Our QoE guide explains each metric.

How AIOZ Stream handles your first upload

Everything above starts with one request: you create a video object with the qualities you want, upload the file to it, then poll its status or wait for a webhook before you hand out playback URLs. The video API reference documents this body for two HLS renditions (codec settings trimmed here):

POST https://api.aiozstream.network/api/media/create
{
  "title": "My Video",
  "type": "video",
  "qualities": [
    { "resolution": "1080p", "type": "hls", "container_type": "mpegts" },
    { "resolution": "720p", "type": "hls", "container_type": "mpegts" }
  ]
}

Change type to dash with container_type set to fmp4 for a DASH rendition. Next step: get your API keys and follow the video API guide.

Frequently Asked Questions

Do I need to transcode video myself before uploading to AIOZ Stream?
No. You upload the source file, and the media API generates the renditions from it at the resolutions you request.

Does AIOZ Stream support both H.264 and H.265?
Yes. H.264 is supported up to 4K and H.265 (HEVC) up to 8K, chosen per rendition.

Is storage separate from delivery on AIOZ Stream?
No. Both run on the same network, which is the main structural difference from a setup where a storage vendor and a CDN are two systems.

Does AIOZ Stream support live streaming?
Yes. You stream over RTMP from OBS Studio, PRISM Live Studio or another RTMP encoder, viewers watch over HLS, and a Low Latency Mode (Beta) is available for interactive broadcasts.

Can I use WebRTC on AIOZ Stream?
The docs don't describe a WebRTC ingest or playback path. Live streams use RTMP in and HLS out, and on-demand video is delivered as HLS or DASH.

How many nodes make up the network?
On Oct 19, 2026, AIOZ's network page listed 329,387 DePIN nodes across the wider AIOZ Network, contributing storage, compute and delivery capacity; it isn't a Stream-only figure.

Related Reading

• Live Streaming on AIOZ Stream: The Complete Guide: stream keys, sessions, restreaming and archiving
• What Is AIOZ DePIN: the node network behind storage and delivery
• One DePIN, Three Workloads: storage, compute and streaming on one network
• What Is Low-Latency HLS: how HTTP delivery gets down to a few seconds
• Glass-to-Glass Latency: What It Is and How to Measure It
• HLS vs WebRTC: choosing a protocol by the delay your use case allows
• What Is a CDN Edge Node: how content is cached and served at the edge
• Widevine vs FairPlay vs PlayReady: what DRM is, whether you need it, and the three main systems
• AIOZ Stream Pricing: what storage, delivery and transcoding cost
• AIOZ Stream vs Livepeer vs Theta: how the three networks differ
• WCAG Video Requirements for Streaming and Video Platforms: captions, audio description and accessible playback
• AIOZ Stream Launch: Peer-to-Peer Live and On-Demand Streaming: the September 2025 launch announcement

References

• AIOZ Stream docs, Video API: resolutions, codecs, HLS and DASH output types
• AIOZ Stream docs, Create Livestream and Viewing and Sharing: stream keys, sessions and Low Latency Mode (Beta)
• AIOZ Stream docs, Livestream Multicast: forwarding a live stream to other platforms
• AIOZ Stream docs, QoE metrics: the composite model and starting targets
• AIOZ Network, AIOZ DePIN: network-wide node count
• HTTP Live Streaming (HLS), Apple Developer: the protocol reference for HLS segments and playlists