Free developer tier

The free developer tier is a real tenant on the production MeshedFlow network, created self-serve from the sign-in page — no card, no sales call. It exists so you can integrate the SDK against real infrastructure and watch genuine peer-delivered bytes before anyone talks about money.

What you get

• A production tenant of your own. Signup provisions a workspace with its own customerId and slug; everything in these docs — the Quickstart, content signing, the SDK reference — works the same way it does for paying customers.
• A portal account. Sign in at app.meshedflow.com for your credentials, content-origin allowlist, per-stream telemetry, and offload figures.
• The same SDK and delivery path. Peer-delivered segments are verified against origin-signed manifests, and anything that can’t be served peer-to-peer falls back to your CDN immediately — the free tier does not run on a separate, smaller network.

The hard limits

The free tier has exactly three limits, and all of them are enforced by the platform, not by the honor system:

Limit	Value	What it means
Concurrent watchers	50 total	Counted across all your streams — 50 on the tenant is the whole allowance at any instant, however it is split.
Watchers per stream	25 max	No single stream may hold more than 25 of those 50 at once — two full streams (25 + 25) is the ceiling.
Streams	2 max	At most two streams can exist on the tenant at once.

50 is a total, 25 is per stream

The watcher pool is shared by every stream on the account, and no one stream may take more than half of it. Two streams do not mean 100 watchers, and one stream cannot use all 50.

What counts as a stream

A stream is one distinct streamId — the identifier you pass to the SDK, formatted <customerId>:<name> (e.g. cust_123:match-day). It names a piece of content, not a rendition: every bitrate and resolution of the same content shares the one streamId, so a full ABR ladder — 1080p, 720p, 480p — is one stream, not three.

The platform counts streams where content signing happens: a stream is “active” while any of its segments was signed within a rolling 6-hour window. The cap is on distinct active streamIds, so:

• signing more segments of an already-active stream never costs anything — it just keeps that stream active;
• a stream that signs nothing for 6 hours drops off the count by itself, and a new one can take its place — no button to press;
• the third distinct streamId inside the window is declined at signing, and those viewers play from your CDN instead.

You run	Distinct active streamIds	Counts as
One match in 1080p + 720p + 480p, all with streamId: "cust_123:match"	cust_123:match	1 stream
That match plus a VOD replay (cust_123:replay)	cust_123:match, cust_123:replay	2 streams — at the cap
A third id (cust_123:extra) while both are still active	—	Declined — signing returns the stream-limit error; playback continues from your CDN

One honest edge case: if a sign request carries no explicit streamId, the platform keys the stream by the segment URL’s directory instead. Segments of one stream live under one path, so this normally lands on the same answer — but a ladder that splits renditions across directories (/720p/, /1080p/) without a streamId would count each directory as its own stream. The SDK sends your configured streamId with every sign request, so this only affects hand-rolled integrations: always set streamId.

What happens at the cap

Nothing breaks, and no viewer sees an error.

• Watcher #51 on the tenant is simply not admitted to the mesh. The platform declines the peer session and the SDK does what it always does when peer delivery isn’t available: playback continues via your CDN. The viewer watches normally; they just don’t contribute to (or benefit from) offload.
• Watcher #26 on a single stream gets the same treatment even while the tenant total is under 50: the platform refuses to sign new segments for that stream, and its overflow viewers fall back to your CDN — your other stream keeps meshing untouched.
• Stream #3 is refused at provisioning time — the request to add it fails with a clear error, and your two existing streams are unaffected.

In other words: the cap limits offload, never playback. Your telemetry in the portal will show the fallback bytes, which is also how you’ll know you’ve outgrown the tier.

Signup walkthrough

1. Open the signup page.

   Go to meshedflow.com/signup. (The same form is also available from the portal sign-in page at app.meshedflow.com under Create free developer account.)

2. Fill in the form.

   Work email, a password (minimum 12 characters, entered twice), and optionally your company name. Submitting creates the free-tier tenant and your owner account in one step.

   • If the email already has an account, you’ll get a conflict message — sign in instead.
   • Signups are rate-limited; if you’re told to wait, wait a minute and retry.

3. Check your email, then sign in.

   Signup deliberately does not log you in. You’ll see your new workspace slug on screen and a welcome note in your inbox — sign in through the normal form with the address and password you just chose.

4. Follow the Quickstart.

   From here the Quickstart applies unchanged: add your content origin to the allowlist, grab signalingUrl / streamId / authToken from the portal, and wire the loader into your player. With one page open in two tabs you can already watch getStats() report peer-delivered bytes.

When you outgrow it

The upgrade path is a measured pilot, not a bigger self-serve plan. A pilot runs one of your real streams control-vs-treatment at production concurrency and hands back a report with offload, playback health, and the economics — that report is what commercial terms are built from.

Request one from meshedflow.com (“Book a measured pilot”) or email pilots@meshedflow.com. Mention your free-tier workspace slug so your existing integration and telemetry carry over.

Live network stats

The aggregate activity of the free developer tier is public: accounts, watchers now, active streams, and bytes served/offloaded, refreshed about once a minute. It’s served from an unauthenticated endpoint on meshedflow.com:

GET https://meshedflow.com/telemetry/public/network-stats

Response shape

{
  "freeTier": {
    "accounts": 0,
    "activeViewers": 0,
    "activeStreams": 0,
    "bytesServed": 0,
    "bytesOffloaded": 0,
    "gbSaved": 0,
    "updatedAt": "2026-08-11T00:00:00Z"
  }
}

Only aggregates are ever exposed — never account names or per-tenant figures. The same stats band shown on meshedflow.com is a reusable widget you can embed on your own page:

Embed the network stats widget

<div data-mf-network-widget></div>
<script src="https://meshedflow.com/js/mf-network-widget.js" defer></script>

The widget renders into any element carrying data-mf-network-widget, fetches the endpoint above, refreshes roughly every 60 seconds, and shows zeros (never an error) when the network is quiet or unreachable.