WAVE is generally available

WAVE's platform is generally available — one API at the gateway, open-core SDKs, and x402 payments that work for people and agents alike. The product surfaces ride on that same API, rolling out in preview. Here's exactly what's live today, and what's next.

WAVE··7 min read
in-browser narration · WAVE Voice (preview) coming soon

Video infrastructure has always been a pile of separate decisions. One protocol for contribution, another for delivery, a different vendor for transcription, a fourth for clips, and a billing system bolted across all of it. Every one of those choices hardened into your codebase, and changing any of them meant changing the system.

WAVE was built on the opposite bet: that the hard part was never any single protocol, but carrying all of them — and the AI that operates on them — through one consistent surface, priced and metered the same way every time. Today the platform that carries it is generally available. That's a specific claim, so this post is precise about it. The spine — the API, the gateway, the docs, the open-core SDKs, and the payment path — is live and general. The product surfaces that ride on it are rolling out in preview behind that same API. Here's the whole map.

What GA means here

The WAVE platform spine is generally available: one gateway at api.wave.online, open SDKs, and x402 payments. Products roll out in preview behind that one API — and you call a preview product the same way you'll call it the day it's GA.

What's generally available today

Four things are live, general, and uncaveated:

  • The gateway. Auth, entitlement, rate-limiting, and metering live once at api.wave.online, in front of everything. One key, one bill.
  • The docs and the changelog. Real reference at docs.wave.online, and dated, versioned changes at changelog.wave.online.
  • The open-core SDKs and tools. A TypeScript SDK and a Python SDK (Go, Rust, and Ruby generated from the same source), a CLI, an MCP server so Claude, Cursor, and Windsurf drive WAVE directly, and an Agent Developer Kit — all public, all installable now.
  • The payment path. x402 settlement on Base and did:wave identity, so an agent can pay per call without an account.

What you can do today, in order:

  1. Point a client at api.wave.online and get a key — or skip the key and let an agent pay per call.
  2. Read the contract at docs.wave.online.
  3. npx create-wave-app, or install the SDK, or drive WAVE from Claude through the MCP server.
  4. Call a metered route; if it's unpaid, the gateway answers 402 with a price an agent can settle and retry.

The two engines

Underneath everything are two jobs. The Media Engine moves the video: one open API where every transport — RTMP, SRT, NDI, MoQ, WebRTC, HLS — is a thin adapter, so the protocol is a parameter of the call, not the shape of your stack.

{
  "ingest": { "type": "srt" },
  "deliver": ["webrtc", "hls"]
}

That call shape is the stable, general part. The individual transport adapters ship at different stages — more on that below. The Money Engine is the other half: it prices a call, settles it, and meters usage, identically for a person with a key and an agent paying over x402.

Why preview-behind-one-API matters

Because auth and metering live once at the gateway, a product going from preview to GA doesn't change how you call it. The integration you write against a preview surface today is the same integration on GA day — you don't rewrite, the label just changes.

In preview, behind the same API

The surfaces that do work on the media are reachable now and labeled preview while they harden:

  • Dispatch — edge AI inference routing, pay-per-call, logging zero prompt content.
  • Render — code-defined video: a Scene in, a deterministic alpha-capable video out. (Its own post goes deeper.)
  • Clip — recordings into clips, thumbnails, and audio.
  • Voice, Transcribe, Captions, Chapters, and Search — synthesis and transcription, broadcast-grade captions, auto-chaptering, and semantic search across your media.
  • Studio-AI, Sentiment, Editor, Podcast, Phone, and Collab — the production-side surfaces.

On the transport side, the MoQ relay, SRT ingest, and the any-to-any bridge are in preview today. Native NDI, Dante, and OMT transport, and the edge WebRTC SFU, are scaffolded and on the way — the API contract for them is already defined; the wire implementations are landing next.

Built for agents, not just people

The reason everything is metered uniformly is that WAVE treats an autonomous agent as a first-class caller. An agent discovers what it can pay for at /.well-known/x402, calls a metered route, gets a 402 with a price, settles on Base, and retries with proof — carrying a did:wave identity that's sanctions-screened. The routes are the ones a person uses; only the payer changes. That path is live today.

What's live, what's in preview

In one place, honestly:

  • Generally available: the gateway and API, the docs, the changelog, the open-core SDKs / CLI / MCP server / ADK, and the x402 + did:wave payment path. (And this blog — it runs on the same platform.)
  • In preview, callable now: Dispatch, Render, Clip, Voice, Transcribe, Captions, Chapters, Search, Studio-AI, Sentiment, Editor, Podcast, Phone, Collab — plus the MoQ, SRT, and bridge transports.
  • On the way: native NDI, Dante, and OMT transport, and the edge WebRTC SFU.

The point

General availability here isn't a wall of finished features — it's a foundation you can build on without betting on vapor. The API is stable, the payments are real, the SDKs are public, and every preview product sits behind the same call you'll make when it's GA. Build against it today; nothing you write gets thrown away when the label changes.

Read the docs Track what ships next

✦preview today, the same call tomorrow

Taggedgaplatformmedia-enginemoney-enginedispatch