Skip to content
Planning a business-critical broadcast? Business-critical broadcast? Talk to a video expert

WHIP Protocol: What It Is, How It Works, and How to Stream With It

WHIP is the IETF standard for pushing live video to a media server over WebRTC. Learn how it works, how it compares to RTMP and SRT, and how to use it.

WHIP Protocol title with a stylized video player and interconnected network nodes on a black background.
In this article

WHIP is the open standard for pushing a live feed from an encoder to a media server over WebRTC. It replaces the custom signaling that once kept WebRTC out of broadcast workflows, so tools like OBS can publish over WebRTC’s real-time transport instead of RTMP.

RTMP dates from the Flash era, when a browser plugin handled two-way video. With Flash retired, browsers can’t publish over RTMP, and its TCP transport pauses to retransmit lost packets, adding first-mile latency. 

On an auction, a live Q&A, or in-play betting, a host who’s seconds behind the chat answers questions the audience has already moved past. WHIP fixes the ingest side with one HTTP request and WebRTC’s encrypted, low-latency transport. 

This guide covers how WHIP works, how it compares with RTMP and SRT, which encoders support it, and how to stream with it on Castr.

What Is the WHIP Protocol?

The WHIP protocol, short for WebRTC-HTTP Ingestion Protocol, is an IETF standard that lets an encoder publish a live stream to a media server or CDN over WebRTC, using a single HTTP request to negotiate the session. 

Four attributes define it:

  • Official standard: The IETF published WHIP as RFC 9725 on the Standards Track in March 2025.
  • Ingest only: Media is unidirectional, from the WHIP client (your encoder) to the server. Playback runs over a separate delivery path.
  • HTTP signaling, WebRTC transport: Session setup runs over HTTPS, while the video and audio travel over WebRTC’s encrypted real-time transport.
  • Token authentication: WHIP clients must support bearer-token authentication, the same pattern web APIs use, though a server can also embed the token in the endpoint URL.

In practice, WHIP streaming means your encoder speaks WebRTC to the server without any vendor SDK in between. The standard was designed to feel as simple as configuring an RTMP ingest URL, and to work the same way in a web browser as in a native or hardware encoder.

How Does WHIP Work?

A WHIP session involves three components, the WHIP client, the WHIP endpoint, and the media server, and moves through 5 steps:

  1. The client sends an offer: The encoder sends an HTTP POST to the WHIP endpoint URL with an SDP offer, which describes its codecs, encryption fingerprints, and, optionally, its ICE candidates.
  2. The server answers: The WHIP server replies “201 Created” with its SDP answer and a Location header pointing to the new WHIP session URL.
  3. The connection is established: Client and server run ICE to negotiate a network path through NATs and firewalls, then complete a DTLS handshake to key the encryption.
  4. Media streams unidirectionally: Video and audio are packetized as encrypted SRTP and sent from client to server.
  5. The client tears down the session: It sends an HTTP DELETE to the session URL, and the server confirms with “200 OK.”

A few details make WHIP practical at scale. The endpoint can load-balance new sessions by redirecting them to a less loaded media server, or tell the encoder to retry when it’s at capacity. It can also return STUN and TURN server configuration so the encoder can traverse restrictive firewalls.

If the server supports ICE restarts, the encoder can send an HTTP PATCH mid-session to restart ICE, which is how a stream can survive a network handover from Wi-Fi to cellular.

The tracks themselves are fixed at setup, so adding a camera or audio feed later means tearing down and re-establishing the session.

Why Was WHIP Created?

WHIP was created because WebRTC never standardized a signaling protocol for session setup. Every streaming service built its own signaling, so encoder vendors couldn’t add one WebRTC output that worked everywhere, and broadcasters stayed on RTMP.

WHIP gives every encoder and server the same HTTP handshake, which is why it could ship once in OBS and interoperate with any compliant endpoint.

The authors also set out to address limits in legacy ingest protocols. Classic RTMP carries a fixed codec set, in practice H.264 and AAC, with no per-session negotiation, so servers often transcode on arrival, which adds latency and degrades quality.

WebRTC negotiates codecs per session and adapts encoding in real time based on RTCP feedback from the receiver. It can also publish multiple renditions at once through simulcast or scalable video coding, reducing the need for server-side transcoding to build an adaptive bitrate (ABR) ladder.

What Is the Difference Between WHIP and WHEP?

WHIP handles ingest into a media server, while WHEP, the WebRTC-HTTP Egress Protocol, handles playback to the viewer’s player. Both use the same pattern of one HTTP POST carrying an SDP offer and one response carrying the answer.

AspectWHIPWHEP
DirectionIngest: encoder to serverEgress: server to viewer
ClientEncoder or browser publishing a streamPlayer or browser watching a stream
Role in the workflowContribution (first mile)Delivery (last mile)
IETF statusPublished standard, RFC 9725Internet-Draft, not yet an RFC

The WHEP draft was revised in October 2026 and submitted to the IESG, the IETF’s approval body, for publication. WHIP and WHEP pair naturally in an end-to-end WebRTC workflow, but only WHIP is a finalized standard.

How Does WHIP Compare With RTMP and SRT?

WHIP offers real-time ingest and publishes natively from browsers, SRT recovers packet loss on long-haul networks, and RTMP is supported by almost every encoder.

AspectWHIPRTMPSRT
TransportWebRTC, usually over UDP (TCP fallback through a TURN relay)TCPUDP with packet retransmission
Session setupOne HTTP POST (SDP offer/answer)RTMP handshake on port 1935Caller, listener, or rendezvous mode, with an optional stream ID
EncryptionAlways on (DTLS-SRTP)None by default; RTMPS adds TLSOptional AES with a passphrase
Typical codecsOpus audio; H.264 or VP8 video as the baseline, plus VP9, AV1, or H.265 where both sides support themH.264 and AAC; Enhanced RTMP adds HEVC, AV1, VP9, and OpusCodec-agnostic (usually MPEG-TS)
Browser publishingYes, nativelyNoNo
Encoder supportGrowing: OBS 30+, FFmpeg 8.0+, GStreamerNear universalBroad in software and hardware encoders

For WebRTC vs RTMP, the trade-off is latency and encryption versus compatibility. For SRT vs WebRTC, it’s resilience on lossy long-haul links versus real-time interaction and browser support.

What Are the Benefits and Limitations of WHIP?

WHIP brings real-time, encrypted ingest to standard tools, but it’s newer than RTMP and only covers the contribution side of the latency chain.

The benefits:

  • Interactive latency: When both publishing and playback run over WebRTC, glass-to-glass latency can drop to around 100 milliseconds, fast enough for a natural conversation with the audience.
  • Open standard on more platforms: RFC 9725 lets any compliant client publish to any compliant server, from web pages and mobile apps to small embedded devices.
  • Built-in encryption: Every session is encrypted with DTLS-SRTP. With end-to-end encryption configured, servers forward the media without being able to read or alter it, which also rules out server-side changes like ad insertion.
  • Browser publishing and co-hosting: A web page can publish with the browser’s native WebRTC stack, so co-hosts and remote guests can join from anywhere WebRTC runs, without installing an encoder.
  • Mobile resilience: When the server supports ICE restarts, a session can recover from network changes, so a phone can hand over between Wi-Fi and cellular without dropping the stream.
  • Codec flexibility: Sessions can negotiate AV1, H.265, and Opus when both sides support them, and custom codecs are possible, which can remove the need to transcode at ingest.
  • Multi-track feeds: One client can publish multiple tracks, such as multiple camera angles or separate audio tracks for multilingual broadcasts.
  • Simpler server stack: WebRTC covers both publishing and playback, so a hosted service has less protocol code to run and maintain.
  • Peer-to-peer links: WebRTC is peer-to-peer at its core, so OBS can stream directly to a browser on another network without a media server. Standard WHIP workflows still publish to a server endpoint.

The limitations:

  • Younger ecosystem: Fewer hardware encoders support WHIP than RTMP or SRT, and some software implementations are still maturing.
  • Encoder settings to change: WebRTC uses Opus for audio rather than AAC, so AAC audio has to be transcoded to Opus, and B-frames should be disabled on the video encoder.
  • Fixed tracks per session: Tracks can’t be added or removed after setup, so adding a feed means re-establishing the session.
  • Network traversal: WebRTC runs over UDP, so networks that block UDP need a TURN relay server or another protocol.
  • Half the latency chain: WHIP only speeds up ingestion. Viewers only get real-time playback if delivery is low latency too.

Which Encoders and Tools Support WHIP?

WHIP works with the major open-source encoders and with any modern browser:

  • OBS Studio: Supports WHIP natively since version 30. In Settings › Stream, choose WHIP as the service, then enter the WHIP endpoint URL and, if your platform uses one, a bearer token.
  • FFmpeg: The WHIP muxer first shipped in FFmpeg 8.0, so you can push streams with “-f whip” from scripts and headless servers. Test it before you rely on it in production.
  • GStreamer: Provides WHIP sink elements for custom media pipelines and hardware integrations.
  • Web browsers: Any browser with WebRTC can act as a WHIP client through a few lines of JavaScript.

OBS WHIP support is the easiest starting point, since it needs no plugin and no code.

How Do You Stream With WHIP on Castr?

You stream with WHIP on Castr by copying your stream’s WHIP endpoint into OBS and going live. The setup takes 5 steps:

➤ Open your live stream: Create a new live stream or open an existing one in your Castr dashboard.

➤ Copy the WHIP endpoint: In the stream’s publish settings, select the WHIP tab and copy the HTTPS WHIP URL.

➤ Configure OBS: In OBS 30 or later, go to Settings › Stream, choose WHIP as the service, paste the URL into the Server field, and apply.

➤ Tune the encoder: In Settings › Output, use constant bitrate (CBR), a 2-second keyframe interval, the zero-latency tune, and the baseline profile. Castr’s docs recommend these settings for sub-second streams.

➤ Start streaming: Click Start Streaming in OBS and verify the incoming feed in the Castr preview.

WHIP delivers your feed to Castr with minimal ingest latency, while the playback delay viewers experience depends on the player tier.

Does WHIP Make Your Whole Stream Low Latency?

No. WHIP reduces latency at ingestion, but glass-to-glass latency also depends on packaging, delivery, and playback. The roughly 100-millisecond figure only applies when viewers also watch over WebRTC. Castr offers three playback tiers:

  • Standard HLS: Around 35 seconds of latency, with the broadest device compatibility.
  • Low Latency player: Under 15 seconds, available on the Ultra plan and up, or on yearly Premium.
  • Sub-Second Streaming: Real-time playback over WebRTC in Castr’s player, sold as an add-on on Premium plans and higher.

When Should You Use WHIP Instead of RTMP or SRT?

Use WHIP when the person on camera has to interact with the audience in real time. Choose your ingest protocol by use case:

  • Interactive streams: Auctions, in-play betting, and live Q&A need real-time latency end to end, so WHIP paired with WebRTC playback is the right fit.
  • Browser-based contribution: When remote guests or field reporters publish from a web page, WHIP needs no installed software.
  • Remote production: Low-latency contribution keeps talkback and on-air timing natural when presenters work from different locations.
  • Mobile field streaming: When the server supports ICE restarts, reporters moving between Wi-Fi and cellular stay live through network handovers without a full reconnect.
  • Multilingual or multi-angle events: Separate tracks let one encoder carry several commentary languages or camera feeds.
  • Long-haul or unstable networks: SRT’s retransmission and tunable latency buffer recover from packet loss more reliably on intercontinental links.
  • Maximum compatibility: RTMP still works with nearly every encoder and suits workflows where you multistream to social platforms.

Start Streaming With WHIP on Castr

The lowest-latency workflow matches each leg of the chain to the right protocol, not one protocol for everything. Real-time ingest matters most when your audience talks back, and broad compatibility matters most when you need the widest possible reach.

Castr supports both from one dashboard. Ingest over RTMP, SRT, or WHIP, choose the playback tier your plan supports, and multistream to more than 30 platforms when reach comes first.

Cloud recording captures your broadcasts for on-demand replay, and viewer analytics show where your audience tunes in and which devices they use.

Start your free 7-day Castr trial and run a test stream from OBS today.