Skip to content

TRaX Edge. A live streaming API on an edge we run ourselves

$0.06

per viewer-hour at any resolution. $0 ingest and encoding, no monthly base, no free tier.

Have an account? Turn on Edge from Billing, then create an API key.

TRaX Edge is a live streaming API for a feed from your own encoder. Push RTMP, RTMPS, SRT, TRT, WebRTC (WHIP) or MoQ to the nearest US point of presence; the API hands back a playback ID, an embed and a player.

Viewers watch over WebRTC (WHEP), HLS, Low-Latency HLS or MoQ. A new account streams to 10 viewers at once: a small church service, a classroom or a prototype. For more, ask about limits.

The first of three requests. The other two point your encoder at it and mint a playback ID.

request
curl -X POST https://api.traxstreaming.live/v1/live-inputs \
  -H "Authorization: Bearer $TRAX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"sunday-service"}'
response
{
  "id": "li_01HZX8K3Q",
  "name": "sunday-service",
  "metadata": {},
  "status": "idle",
  "maxBitrateKbps": 8000,
  "latency": "low",
  "streamName": "l/5f2c1a90",
  "createdAt": "2026-11-14T15:04:05Z",
  "updatedAt": "2026-11-14T15:04:05Z"
}

How a stream moves through TRaX Edge

  1. Your encoder
    OBS, vMix, a hardware box or a browser
    → RTMP, SRT, TRT, WHIP or MoQ
  2. Nearest TRaX point of presence
    US East, US Central, US West
    → our own edge software, passthrough
  3. Playback ID
    public or signed by your backend
    → WebRTC, HLS, LL-HLS or MoQ
  4. Your viewers
    watch page, embed or player

Three requests from encoder to viewer

Same host, keys, error envelope and cursor pagination as the rest of the TRaX public API at api.traxstreaming.live/v1. The API reference and the OpenAPI spec list every route, and Account and API keys shows how to make a key.

  1. Create a live input

    One POST. Name it, and optionally cap its bitrate.

    The request and its JSON are at the top of this page. The next two requests use this field:

    "id": "li_01HZX8K3Q"
  2. Point your encoder at it

    Name the protocols you want, from RTMP, RTMPS, SRT, TRT, WHIP and MoQ, and the ingest call returns each URL with the stream key filled in. Paste one into OBS, vMix or a hardware encoder: the OBS and ffmpeg quickstart shows where it goes, and SRT or RTMP compares the two.

    request
    curl -X POST https://api.traxstreaming.live/v1/live-inputs/li_01HZX8K3Q/ingest \
      -H "Authorization: Bearer $TRAX_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"protocols":["rtmp","srt"]}'
    response
    {
      "streamName": "l/5f2c1a90",
      "ingestUrls": {
        "rtmp": {
          "complete": "rtmp://ingest.traxstreaming.live:1935/l/5f2c1a90?user=sk_in_7Hq2&pass=sk_in_7Hq2",
          "base": "rtmp://ingest.traxstreaming.live:1935/l/5f2c1a90"
        },
        "srt": {
          "complete": "srt://ingest.traxstreaming.live:8890?streamid=publish:l/5f2c1a90:sk_in_7Hq2:sk_in_7Hq2&latency=200",
          "base": "srt://ingest.traxstreaming.live:8890"
        }
      },
      "granted": ["rtmp", "srt"],
      "streamKey": "sk_in_7Hq2"
    }
  3. Mint a playback ID and embed it

    Public, or signed by your backend. The response carries the watch URL, the embed HTML and the player token URL.

    request
    curl -X POST https://api.traxstreaming.live/v1/live-inputs/li_01HZX8K3Q/playback-ids \
      -H "Authorization: Bearer $TRAX_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"policy":"public"}'
    response
    {
      "playbackId": "Zk3vT8q2LxW0aYc5RnB7Hg",
      "liveInputId": "li_01HZX8K3Q",
      "policy": "public",
      "createdAt": "2026-11-14T15:06:41Z",
      "watchUrl": "https://watch.traxstreaming.live/p/Zk3vT8q2LxW0aYc5RnB7Hg",
      "embedHtml": "<iframe src=\"https://watch.traxstreaming.live/p/Zk3vT8q2LxW0aYc5RnB7Hg?embed=1\" width=\"640\" height=\"360\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen></iframe>",
      "player": { "tokenUrl": "https://api.traxstreaming.live/v1/playback/Zk3vT8q2LxW0aYc5RnB7Hg/token" }
    }

What you get with TRaX Edge

Live inputs
RTMP, RTMPS, SRT, TRT, WebRTC (WHIP) and MoQ ingest at the nearest US point of presence, a stream key per input, and key rotation that disconnects the live publisher. 1 live input at a time on a new account, 2 after 30 days and a paid invoice.
Playback IDs
Several per input, each public or signed. A signed ID is checked against a token your own backend signs with an ES256 key we issue once and never store, so revoking one leaked link leaves the others working. The playback token route is in the API reference.
Playback
WebRTC (WHEP), HLS, Low-Latency HLS and MoQ, on a hosted watch page, an iframe embed or a player web component for your own page. WebRTC and MoQ are the real-time choices, Low-Latency HLS keeps delay low for a large audience, and HLS plays on the most devices. Viewers get the resolution and bitrate you push.
Webhooks and usage
Four events, HMAC-signed, with 30 days to replay:live_input.connectedlive_input.disconnectedlive_input.capacity_reachedusage.threshold_crossedThe webhooks reference has the signature and the retry schedule. The usage API reports viewer-hours by hour and region, and its totals match your invoice.

What TRaX Edge costs

Pay as you go, billed on its own invoice each month, separate from any Studio plan.

  • No monthly base and no free tier: a card is required before you create anything.
  • Nothing is charged up front: you pay only for the viewer-hours used. A monthly spending limit, set to $50 until you change it, caps the bill: delivery stops at the limit, and nothing past it is billed.
  • A one-hour service watched by 10 people costs $0.60. A 90-minute class watched by 20, on an established account, costs $1.80.
TRaX Edge prices
TRaX EdgePriceUnit
Delivery, every resolution$0.06per viewer-hour, metered per minute
Ingest, encoding and live-input hours$0passthrough, no transcode, no per-hour input fee
Realtime channels, connections$1.00per million connection-minutes, data only
Realtime channels, data$0.10per GB; messages are counted, not billed

Published rates at three other vendors

Edge matches Cloudflare’s delivery rate and is 1.2 cents a viewer-hour above Mux’s starting rate. Mux adds about $1.50 an hour for the live input and IVS doubles its rate from SD to HD; Edge charges neither. Cloudflare and Mux transcode to an adaptive ladder at those rates, and Edge delivers the one rendition you push.

Vendor figures are the published starting rates on the page each name links to, read 2026-11-14.

Delivery price per viewer-hour and how it is billed, read from each vendor's pricing page on 2026-11-14
VendorPer viewer-hourHow it is billed
TRaX Edge$0.06every resolution; no ingest or encoding fee
Cloudflare Stream Liveabout $0.06$1 per 1,000 minutes delivered; no ingest or encoding fee
Mux Liveabout $0.048from $0.0008 a minute, plus a live input from $0.025 a minute, about $1.50 an hour
AWS IVS low latency$0.036 to $0.144$0.036 SD, $0.072 HD, $0.144 full HD (US), plus input billed per channel-hour by type

Account limits

Each account has a limit on concurrent viewers, live inputs and realtime connections. The limits rise once the account is established, and on request after that.

Limits for new and established accounts
Per accountNew accountEstablished
Concurrent viewers1020
Live inputs at once12
Realtime connections, concurrent200500

New account: a card on file. Established: 30 days and one paid invoice with no dispute.

What Edge leaves out

Edge is live delivery and an API. Six things other live streaming APIs include are not part of it.

  • Recording, VOD or DVR: Edge delivers live only
  • Transcoding or an ABR ladder: viewers get the rendition you push
  • Simulcast to YouTube, Twitch or Facebook: that is Studio
  • Delivery from points of presence outside the US
  • A service level agreement: incidents are posted on the status page
  • Organisations and teams: API keys belong to one user

Adult content is not allowed, and every watch page carries a Report link. Incidents and maintenance are posted at status.traxstreaming.live. TRaX Streaming runs the edge software itself, on servers it leases in US data centres: security and subprocessors, about the company.

Realtime channels

Low-latency data on the same account and API keys as your video. $1.00 per million connection-minutes plus $0.10 per GB delivered; messages are counted, not billed.

What it carries
Application data for interactive apps: chat and reactions beside a stream, multiplayer cursors, auction bids, live scores, telemetry. Messages up to 64 KiB, delivered to every subscriber.
Apps and channels
An app is the unit: its own channels, allowed browser origins and signing keys. Channels are created on first publish.
State and presence
The newest message per channel is kept so a late joiner sees the current state; no other history. Presence reports who is in a channel. Your backend can publish over REST without holding a socket.
Transport
MoQ on WebTransport, with a WebSocket fallback for browsers and networks where WebTransport is blocked.

Questions about TRaX Edge

What is a live streaming API?

A live streaming API is a set of HTTP routes that take a live video feed from an encoder and hand back a playback URL or a player, so an application creates, secures and embeds streams from code instead of a dashboard. The usual parts are an ingest endpoint over RTMP or SRT, playback over HLS or WebRTC, webhooks for stream state, and metered usage. TRaX Edge has each of those.

What does the TRaX Edge live streaming API do?

It takes one live feed from your encoder over RTMP, RTMPS, SRT, TRT, WebRTC (WHIP) or MoQ and delivers it to viewers over WebRTC (WHEP), HLS, Low-Latency HLS or MoQ. Three REST calls create the live input, return the ingest URLs and mint a playback ID with a watch page and an embed. It costs $0.06 per viewer-hour, with no ingest or encoding fee.

How is TRaX Edge different from TRaX Studio?

Studio is the browser production tool: a scene canvas, guests by link, cloud encoders and simulcast to YouTube, Twitch and the rest, on plans from $12.49 a month. Edge is delivery only: you bring the encoder and we hand back playback. One account can hold both. A Studio plan’s included viewer-hours apply to the studio program, not to Edge inputs.

Which browsers and devices can play a TRaX Edge stream?

Every playback ID plays over WebRTC (WHEP), HLS, Low-Latency HLS and MoQ. A browser plays WebRTC without a plugin, and a player or TV app that takes an HLS URL plays the HLS stream. Use WebRTC or MoQ when viewers need real time, Low-Latency HLS for low delay with a large audience, and HLS for the widest device reach. Video reaches viewers as you pushed it; over WebRTC, AAC audio is delivered as Opus.

How do I start using TRaX Edge?

Sign up, add a card, and turn on Edge from the billing page of your account. Create an API key under Settings, Developer, then create a live input with one POST and point your encoder at the ingest URL it returns.

Is there a free tier or a trial?

No. Edge is billed from the first minute at $0.06 per viewer-hour, and a card is required before you can create a live input. Nothing is charged up front and there is no minimum: you pay only for the viewer-hours used. Each account has a monthly spending limit, set to $50 until you change it. Delivery stops at the limit, and nothing past it is billed.

Does TRaX Edge record my stream?

No. Edge delivers live only. If you need a recording, record at the encoder or point a Studio output at an archive destination.

Where does it run, and is there an SLA?

On US points of presence in three regions: US East, US Central and US West. An encoder publishes to the nearest one. Edge has no service level agreement; incidents and maintenance are posted on the status page at status.traxstreaming.live.

Need the studio too? Studio plans and prices, or how Studio compares with StreamYard, Restream and Boxcast.

Push a stream to TRaX Edge

  1. Sign upCreate an account and add a card. Nothing is charged until viewers watch.
  2. Turn on EdgeEnable it on the billing page, then create an API key.
  3. Go liveCreate a live input, point your encoder at it and embed the playback ID, at $0.06 per viewer-hour.