Live CCTV as a service

Put a live camera on your site with one API call.

StreamBridge ingests your RTSP and RTMP cameras, converts them to browser-ready HLS, and hands your application a signed playback URL. No streaming server to run. No FFmpeg to babysit.

RTSP · RTMP in — HLS out

2Ingest protocols
H.264 + H.265Passthrough or transcode
~5sHLS glass-to-glass
1 callFrom camera to embed
Compatibility

If the camera speaks RTSP, it works.

StreamBridge talks to cameras the way every camera already expects — no agent on the network, no vendor SDK, no firmware requirement. Paste the RTSP address the camera already publishes, or let an encoder push RTMP to a stream key we issue.

Uniview Hikvision Dahua Axis Bosch Reolink TP-Link VIGI Ezviz Amcrest

Brand names are shown to indicate protocol compatibility, not endorsement or partnership.

Pull

We connect to the camera

Give us an rtsp:// or rtmp:// address — including behind dynamic DNS — and StreamBridge maintains the connection, reconnecting on its own when the link drops.

Push

The camera connects to us

When a camera sits behind NAT with no port forwarding, StreamBridge issues a stream key and the encoder pushes RTMP to us instead.

Verify

Test before you commit

Every camera is probed before it is saved. A wrong password, an unreachable host or an unsupported codec is reported as exactly that — not as a silent failure later.

The alternative

Everything between a camera and a browser, already built.

A camera speaks RTSP. A browser does not. Closing that gap yourself means running a media server, keeping an FFmpeg process alive per camera, segmenting HLS, and then inventing an access-control layer so your streams are not open to the internet.

Building it in-house

  • Run and patch a media server
  • Supervise one FFmpeg process per camera, forever
  • Detect stalls, reconnect, avoid flapping
  • Build your own token, domain and viewer limits
  • Write the recording, retention and playback UI

Using StreamBridge

  • Register the camera once, in the dashboard or by API
  • Streams start, reconnect and self-heal on their own
  • Ask for a playback session, get a signed HLS URL
  • Expiry, allowed domains and viewer caps come with it
  • Recording, timeline playback and retention included
STEP 01

Register the camera

Paste the camera's RTSP or RTMP address — or let StreamBridge issue a stream key and have the camera push to us. Test the connection before you save it, and import in bulk when you have a whole site to onboard.

STEP 02

Request a playback session

Your backend calls the sessions endpoint with an API key. You get back a session ID, an HLS URL and an expiry timestamp. Batch the call when a page shows a whole wall of cameras.

STEP 03

Embed it

Drop the URL into hls.js, any HLS-capable player, or the generated iframe. The stream plays only from the domains you allow, only for as long as the session lives.

The integration

Two requests. That is the whole integration.

Authenticate with an API key scoped to a project or site. Everything else — transcoding profile, session lifetime, who is allowed to watch — is resolved server-side from the policy you configured.

Request a session
# Your backend, once per page load
curl -X POST https://api.streambridge.io/api/cameras/CAMERA_ID/sessions \
  -H "X-API-Key: YOUR_API_KEY"

# 201 Created
{
  "sessionId": "1f0c9a4e-…",
  "hlsUrl":    "https://…/playback/stream/…m3u8?token=…",
  "expiresAt": "2026-08-18T09:41:00Z"
}
Play it
// Your page
<video id="cam" controls autoplay muted></video>

const hls = new Hls();
hls.loadSource(session.hlsUrl);
hls.attachMedia(document.getElementById('cam'));

// …or skip the player entirely
<iframe src="https://…/embed/CAMERA_ID?token=…"
        allowfullscreen></iframe>
Batch

One call, many cameras

A site page with forty tiles does not need forty round trips — request every session in a single batch call and get per-camera results and errors back together.

OpenAPI

Interactive reference

The built-in Developer Portal documents every endpoint, lets you fire test requests against your own account, and generates the embed snippet for you.

Webhooks

Events, pushed to you

Subscribe to camera events — online, offline, degraded, recording — and react in your own system instead of polling ours.

Capabilities

A full operations console, not just a video pipe.

Your team gets a dashboard for the day-to-day work; your developers get the API. Both sit on the same organisation, projects, sites and cameras.

Processing

Reusable stream profiles

Define resolution, codec, frame rate and audio once, then apply the profile across cameras. Passthrough when the source is already right; transcode when it is not — and changes reach running cameras without a restart.

Resilience

Self-healing streams

Health checks, stall detection and automatic reconnect run continuously. A camera that recovers comes back on its own, and one that is genuinely broken stops flapping instead of retrying forever.

Recording

Record and scrub back

Record any camera with a retention policy per organisation. Browse the archive on a 24-hour timeline with an activity heatmap and jump straight to the moment.

Map

Cameras on a map

See every site geographically, with live status, recording and maintenance badges, and a 16:9 preview in the popup. Filter down by tag.

Fleet

Bulk operations

Start streams, toggle recording, enter maintenance or remove cameras across a whole selection, with per-item results when only some succeed. Import a site's worth of cameras from one file.

Maintenance

Planned downtime, quietly

Flag a camera as under maintenance with a reason, and alerts and webhooks stay silent until it comes back — no false alarms during a site visit.

Public viewer

A public wall, no code

Publish a selected set of cameras to a branded public page with your own title, logo and colour — for a lobby screen, a city view or a tourism site.

Governance

Roles and audit trail

Admin, Operator, Developer and Viewer roles with per-user overrides, and an audit log that records who changed what, when.

Scale

Edge nodes

When viewer counts outgrow a single origin, edge nodes fan the same stream out to more viewers while the origin still pulls the camera exactly once.

Access control

A stream URL that leaks is not a breach.

Playback is never a permanent link. Every session is minted for one camera, expires on a clock, and is refused outside the domains you named.

Policies inherit — set them once, override where it matters

Cameramost specific — wins
Sitefalls back to
Projectfalls back to
Systemplatform default

Give a whole project a two-hour session TTL, then tighten a single sensitive camera to five minutes. Nothing else has to change.

Session TTL

Playback URLs carry an expiry. When it passes, the URL stops working — whoever is holding it.

Domain allowlist

The stream plays only when embedded on a domain you listed. Copy the link elsewhere and it refuses.

Viewer limits

Cap concurrent viewers per camera so one popular embed cannot consume the bandwidth of an entire site.

Rate limits per key

Session creation is throttled per API key and per camera, so a runaway client degrades itself and nobody else.

Tenant isolation

Organisations are isolated at the database row level. A key scoped to one project cannot reach another organisation's cameras.

LayerWhat StreamBridge supports
Ingest — pullRTSP and RTMP, including cameras behind dynamic DNS
Ingest — pushRTMP to a platform-issued stream key, for cameras behind NAT
DeliveryHLS over HTTPS, playable by hls.js, Safari and any standards-compliant player
Video codecsH.264/AVC and H.265/HEVC, passthrough or re-encoded by profile
LatencyApproximately five seconds glass-to-glass on standard HLS
HierarchyOrganisation → Project → Site → Camera, with policies resolved along that chain
RolesAdmin, Operator, Developer, Viewer — plus per-user permission overrides
RecordingPer-camera recording with timeline playback and activity heatmap
Retention1 to 365 days, set per organisation and overridable per camera; expired footage is rotated out automatically
IntegrationREST API with OpenAPI reference, scoped API keys, and event webhooks

Swipe the table sideways to see every column

Plans

Priced on the four things that actually cost money.

Cameras, concurrent viewers, bandwidth and storage. Every plan is provisioned for your organisation, so the numbers below are starting shapes — tell us your fleet and we will size it.

Starter

Starter

One site, going live for the first time.

Cameras10
Viewers / camera10
Look back7 days
Storage250 GB
  • Live streaming & embeds
  • API keys & Developer Portal
  • 7-day rolling recordings
Talk to us
Pro · most chosen

Pro

A few sites, with footage worth keeping.

Cameras50
Viewers / camera50
Look back30 days
Storage1 TB
  • Everything in Starter
  • 30-day recordings & timeline
  • Map view & webhooks
Request access
Max

Max

Many sites, audited, published publicly.

Cameras200
Viewers / camera200
Look back90 days
Storage5 TB
  • Everything in Pro
  • Audit log
  • Public CCTV viewer
Talk to us
Enterprise

Enterprise

Fleet scale, sized and supported to fit.

CamerasCustom
Viewers / cameraCustom
Look back365 days
StorageCustom
  • Everything in Max
  • Edge nodes for viewer scale
  • Dedicated onboarding
Talk to us
Compare

What each plan includes

Feature Starter Pro Max Enterprise
Limits
Cameras1050200Custom
Concurrent viewers per camera1050200Custom
Recording look-back7 days30 days90 days365 days
Recording storage250 GB1 TB5 TBCustom
Streaming
RTSP & RTMP ingest✓✓✓✓
HLS playback sessions✓✓✓✓
Embed code & iframe✓✓✓✓
Stream profiles & transcoding✓✓✓✓
H.265 / HEVC✓✓✓✓
Self-healing & stall detection✓✓✓✓
Maintenance mode✓✓✓✓
Developer
REST API & API keys✓✓✓✓
Developer Portal & OpenAPI✓✓✓✓
Batch session creation✓✓✓✓
Event webhooks—✓✓✓
Operations
Dashboard & notifications✓✓✓✓
Bulk actions & import✓✓✓✓
Recordings & timeline playback✓✓✓✓
Per-camera retention override✓✓✓✓
Map view—✓✓✓
Audit log——✓✓
Public CCTV viewer——✓✓
Access & scale
Session TTL & domain allowlist✓✓✓✓
Policy inheritance✓✓✓✓
Roles & permission overrides✓✓✓✓
Edge nodes———✓
Dedicated onboarding———✓

Swipe the table sideways to compare all four plans

Plan limits and feature access are configured per organisation — the tiers above are typical shapes, not fixed products. Delivery bandwidth is subject to fair use rather than a metered cap.

Send us one camera. We will send back a URL.

The fastest way to evaluate StreamBridge is to point a single camera at it. Tell us the protocol you have and roughly how many cameras you are planning for, and we will provision an organisation for you.