# Does iroh Support WebRTC? QUIC-Based Networking Explained

> Discover if iroh supports WebRTC. Learn about iroh's exclusive QUIC-based transport, mandatory TLS, and why it doesn't offer WebRTC data channel APIs for modern networking.

- Repository: [number zero/iroh](https://github.com/n0-computer/iroh)
- Tags: deep-dive
- Published: 2026-06-23

---

**No, iroh does not support WebRTC; the library exclusively implements QUIC-based transport with mandatory TLS configuration, offering no WebRTC data channel APIs.**

The n0-computer/iroh repository provides a peer-to-peer networking stack built entirely on the QUIC protocol. If you are evaluating iroh for projects requiring WebRTC connectivity, you will find that the codebase deliberately implements QUIC-based transport mechanisms instead, making native WebRTC integration impossible without external libraries.

## Why iroh Uses QUIC Instead of WebRTC

Iroh's networking layer is built around **QUIC** for both reliable and unreliable peer-to-peer communication. According to the source code in [[`src/lib.rs`](https://github.com/n0-computer/iroh/blob/main/src/lib.rs)](https://github.com/n0-computer/iroh/blob/main/iroh/src/lib.rs) (lines 244-248), the library's top-level documentation explicitly references QUIC and QUIC-based address discovery. All core connection logic, socket handling, and NAT traversal mechanisms are implemented on top of QUIC in [`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs) and [`src/net_report.rs`](https://github.com/n0-computer/iroh/blob/main/src/net_report.rs), leaving no infrastructure for WebRTC's ICE, DTLS, or SCTP protocols.

## How iroh's QUIC Transport Works

### The Endpoint API

The public API for establishing connections resides in [`src/endpoint.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint.rs). The `Endpoint` struct serves as the primary interface for peer-to-peer interactions, exposing methods like `connect` and `listen` that operate exclusively over QUIC. Unlike WebRTC, which requires separate `RTCPeerConnection` and data channel abstractions, iroh handles streams directly through QUIC's native multiplexing via the `Endpoint` object.

### TLS Configuration Requirements

Every iroh connection requires **TLS** encryption. The [`src/tls.rs`](https://github.com/n0-computer/iroh/blob/main/src/tls.rs) file implements `TlsConfig`, which the `Endpoint::builder()` consumes when initializing the transport. This differs from WebRTC, which uses DTLS for encryption and requires separate certificate negotiation. In iroh, you must provide a `TlsConfig` (typically self-signed for testing via `TlsConfig::new_self_signed()`) before binding the endpoint.

Below is a minimal example showing how to create an iroh endpoint with QUIC enabled:

```rust
use iroh::endpoint::{self, quic::QuicTransportConfig};
use iroh::endpoint::Endpoint;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Load TLS certificates (self‑signed for testing)
    let tls_config = iroh::tls::TlsConfig::new_self_signed()?;

    // Enable QUIC address discovery (optional)
    let quic_cfg = QuicTransportConfig::default();

    // Build the endpoint
    let ep = Endpoint::builder()
        .tls_config(tls_config)
        .quic_transport(quic_cfg)
        .bind()
        .await?;

    println!("Local endpoint ID: {}", ep.id());

    // Example: connect to a remote endpoint (replace with real ID & address)
    // let remote_id = "...".parse()?;
    // let conn = ep.connect(remote_id).await?;
    // // Use `conn` to send/receive streams...

    Ok(())
}

```

Key implementation details from the source:

- **`iroh::tls::TlsConfig`** – Always required for encryption, implemented in [`src/tls.rs`](https://github.com/n0-computer/iroh/blob/main/src/tls.rs)
- **`QuicTransportConfig`** – Created via `quic_transport()` on the builder, defined in [`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs)
- **`Endpoint`** – All P2P interactions (streams, connections, NAT traversal) use this struct with no WebRTC abstraction available

## Key Source Files in the Networking Stack

- **[`src/lib.rs`](https://github.com/n0-computer/iroh/blob/main/src/lib.rs)** – Crate root providing high-level documentation. Lines 244-248 explicitly mention QUIC and address discovery, confirming the absence of WebRTC.
- **[`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs)** – Implements the QUIC transport, server/client configuration, and ALPN handling.
- **[`src/endpoint.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint.rs)** – Public endpoint API including `Endpoint::builder`, `connect`, and `listen` methods.
- **[`src/tls.rs`](https://github.com/n0-computer/iroh/blob/main/src/tls.rs)** – TLS configuration utilities used by both TCP and QUIC transports.
- **[`src/net_report.rs`](https://github.com/n0-computer/iroh/blob/main/src/net_report.rs)** – Implements network probing including QUIC address discovery for NAT traversal.

## Summary

- Iroh does not implement WebRTC APIs; the transport layer is exclusively QUIC-based as documented in [`src/lib.rs`](https://github.com/n0-computer/iroh/blob/main/src/lib.rs).
- The `Endpoint` API requires `TlsConfig` from [`src/tls.rs`](https://github.com/n0-computer/iroh/blob/main/src/tls.rs) and `QuicTransportConfig` from [`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs) for all connections.
- NAT traversal is handled through QUIC address discovery in [`src/net_report.rs`](https://github.com/n0-computer/iroh/blob/main/src/net_report.rs), not WebRTC's ICE framework.
- Developers requiring WebRTC must integrate a separate library, as iroh's current API surface provides no WebRTC functionality.

## Frequently Asked Questions

### Does iroh support WebRTC for peer-to-peer connections?

No, iroh does not support WebRTC. The library uses QUIC for all peer-to-peer communication as implemented in [`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs), including connection establishment and data transfer. No APIs for WebRTC data channels, `RTCPeerConnection`, or ICE candidates exist in the public interface.

### Can I use WebRTC alongside iroh in the same application?

While you can technically run a separate WebRTC library in your application, iroh exposes no APIs for WebRTC integration. The `Endpoint` struct in [`src/endpoint.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint.rs) only handles QUIC connections, so the two transports would operate independently without native interoperability.

### What protocol does iroh use for NAT traversal without WebRTC?

Iroh implements NAT traversal using QUIC-based address discovery mechanisms located in [`src/net_report.rs`](https://github.com/n0-computer/iroh/blob/main/src/net_report.rs) and [`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs). This approach replaces WebRTC's ICE (Interactive Connectivity Establishment) framework with QUIC-specific probing and hole-punching techniques.

### Is there any WebRTC functionality hidden in the iroh source tree?

No, analysis of [`src/lib.rs`](https://github.com/n0-computer/iroh/blob/main/src/lib.rs), [`src/endpoint.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint.rs), and [`src/endpoint/quic.rs`](https://github.com/n0-computer/iroh/blob/main/src/endpoint/quic.rs) confirms that the only transport options are the default TCP/UDP fallback and the QUIC transport. The source tree contains no references to WebRTC, DTLS, or SCTP protocols.