txrx
txrx.run · the transport

The shared stage. Everyone, person or agent, joins your live show on the rig they already run.

txrx stands in front of the roads you already run - SRT, NDI, Dante, AES67, mesh and MoQ - and hands a stream from one to the next. It invents no transport. Each road keeps its own rules.

SRT→NDI01 / 06
example crossings · staticexample feed
example · not live yet · no packets move
01 · loss stays home

Recovery stays on its road.

A packet lost on SRT is recovered by SRT. The seam sees it once, or not at all.

02 · no fill

Missing media stays missing.

An audio road never gains video at the seam. A late object is dropped, not replaced.

03 · one identity

The stream keeps its name.

str_818 goes in and str_818 comes out, whatever road it rides.

the conversion grid · 6 × 6

Thirty crossings. One running now.

Rows send, columns receive. The grid steps through every crossing on its own. Pick a tile to hold it.

tx ↓ / rx →cycling
01 / 30
SRT → NDI
clean
hop log · str_818stepping
example · not live yet
road by road

Stand on one road. Read its board.

Every road it hands off to, every road that hands off to it, and what each crossing keeps.

road profileSRT
5 crossings
example · not live yet
console · example · not live yet

What moved. What stopped.

Every total is the sum of the rows under it. Pick a road to filter. Open any stream to read its receipt.

streams
0
running · example
0
moved
0
stopped at the seam
0
streams
streamcrossingclassstatesecondsmoved
example · not live yet · totals computed from the rows on this page
txrx.run/r/818

One stream, across the seam.

The receipt names the roads, what crossed, what stayed behind, and how much moved. It names no person.

str_818clean
SRT → NDI
receipt.json
example · not live yet · toll is on the pricing page · open other streams from the console
connect · the shared stage

Send on your road. Receive on theirs.

Pick the road you send on and the road they receive on. The shared stage. Everyone, person or agent, joins your live show on the rig they already run. Each side gets the address its own road expects, and the seam hands the stream across.

tx · you send onSRT
rx · they receive onNDI
the namenot made
-
make the name to see both addresses.
example · not live yet · nothing is provisioned
fan-out · example · not live yet

Send once. Every road receives.

Send one stream on your road. Pick every road that should receive it. Each receiving side gets the address its own road expects, and each crossing keeps what that road can carry.

tx · you send onSRT
rx · receiving roads3 roads
the name3 crossings
-
example addresses on txrx.example · not live yet · nothing is provisioned
meter · every road

Any road in. One meter for all of it.

Every stream is counted at the seam, the same way on every road: seconds across and megabytes moved. Turn a road off to see it leave the total.

roads counted
6
streams
0
seconds across
0
moved
0
roadstreamssecondsmovedrate
one metersee pricing
example · not live yet · totals computed from the rows on this page · one toll, every road
recovery · loss stays home

Lost on a road. Recovered on that road.

Pick the road you send on and drop some packets. The road recovers them its own way, before the seam. The seam hands each packet across once. What the road cannot recover stays missing.

tx · you send onSRT
packets lost on the road2 of 12
on SRTARQ retransmit
across the seam12 crossings
example · not live yet · recovery belongs to each road
txrx.run / recovery room

Keep the crossing clean.

Watch source loss, recovery on the road and what actually crosses the seam. Choose a road and a loss pattern.

stream · str_818carrying
tx · roadSRT
→
rx · roadNDI
across the seam12 / 12
road and loss2 lost
source road
loss pattern
at the source12 packets
on the road
across the seam
the recovery room
crossing recordlocal scenario
txrx.run / crossing incident

One path stops. The stream stays named.

Replay a primary-road loss and watch the standby carry the next packet. No duplicate crossing, no second stream.

incident replayready
timeline · str_8180 / 5
crossing state00:00
primary · SRTcarrying
standby · MESHready
packets sent0
crossed once0
missing0
packet ledgerone seam
incident recordlocal replay
txrx.run / stream health · example · not live yet

See what crosses. See what drops.

Follow one example stream from source road to receiving road. The seam counts what passes; source loss, local recovery and missed deadlines stay distinct.

stream
source road
→
receiving road
example tick
at the seam
acrossseconds counted
movedsource volume
intervalslocal steps
road eventsexample sequence
health recordlocal only
Example · not live yet · no live probe, telemetry, account connection, actual packet loss, receipt or alert.
txrx.run / crossing compatibility bench · example · not live yet

What survives the seam?

Choose two of the six roads and the distance. Read the media boundary and an example glass-to-glass budget before adding the local ask to the bench.

source / receivesix known roads
sending road
receiving road
distance
crossing
source
→
receive
at the seam
example budget
bench / one row per ask0 asks
local compatibility JSONnothing transmitted
Example · not live yet · no transcoding, codec ladder, GPU compute, price, live route, deadline guarantee or stream is created.
txrx.run / crossing plan · example · not live yet

Choose the roads.
Read the deadline.

Set a sending road, receiving road and distance. See the example glass-to-glass budget, road recovery and what the seam keeps. Nothing is scheduled or transmitted here.

tx · sending roadSRT
rx · receiving roadNDI
distancesame city
crossing classone seam
example glass to glassnot a service promise
budget by legexample ms
road behaviorsource · seam · destination
local plan recordnot scheduled
Example · not live yet · no date, reservation, live route, transmitted stream or deadline guarantee.
txrx.run / redundancy planner · example · not live yet

One signal.
Two roads.

Rehearse a primary and fallback road across the same seam. A second road may cover an interruption; it cannot change the media, clock or deadline the receiving side needs.

transport choicesnot provisioned
primary road
fallback road
receiving road
distance

crossing planexample · not live yet
PRIMARY
→
RECEIVE
FALLBACK
local_redundancy_plan.jsonunsent · unscheduled
Example · not live yet. No transcoding, codec ladder, GPU, compute job, route reservation, live switch, transmitted stream, fee or guaranteed recovery occurs.
docs · example · not live yet

Three calls. Every road.

Open a stream, read its crossings, fetch its receipt. The same calls cover every road txrx stands in front of.

endpointstap one
request
response200
example · not live yet
for agents · POST /v1/streams

Told what it loses. Before it sends.

An agent names the road it has, the road on the far side, and what must survive the crossing. txrx answers before a byte moves: what the crossing keeps, what it drops, and whether that breaks the ask.

the askclean

before a byte moves
response

the name
-
example · not live yet · nothing is provisioned · counted at the seam in seconds and megabytes
pricing · the toll

One toll per crossing. Any road in.

txrx charges for the crossing, not the road. Every road pays $0.002 per crossing-minute, counted at the seam. Any free allowance is set at launch.

road in
how long it crosses
roads it crosses to
    crossing-min
    toll

    never on the toll$0
    • A crossing stopped at a boundary$0
    • Reading a receipt or the meter$0
    • Naming a stream, signing in$0
    See the count on the meter and a crossing on a receipt.
    every line
    lineprice
    Toll per crossingOne rate for every road in: SRT, NDI, Dante, AES67, mesh, MoQ, WHIP, RTMP and bridges.$0.002 / crossing-min
    Free allowanceFree crossing-minutes each month, if any.set at launch
    Per ingestNo separate charge for bringing a stream in. It is part of the toll.$0 · in the toll
    Viewer deliveryNot charged here. txrx moves streams in and across; playback to viewers is priced on the playback side.not charged here
    example · not live yet
    sign in

    Sign in to txrx.

    example · not live yet · nothing is sent · new to txrx? start here
    latency · glass to glass

    Every millisecond has a road.

    Pick the road you send on, the road they receive on, and how far apart you are. Each road spends its own buffer. The long haul rides a road built for it. The seam adds almost nothing.

    tx · you send onSRT
    rx · they receive onNDI
    how far apartsame city
    glass to glass
    example · not live yet · each road keeps its own buffer
    start

    Start on txrx.

    the road you send on first

    example · not live yet · nothing is sent · already on txrx? sign in
    404

    No road goes here.

    back to the roads →