---
hide_title: false
hide_table_of_contents: false
pagination_next: null
pagination_prev: null
---
# ReadableStream.tee()

The **`tee()`** method of the
`ReadableStream` interface [tees](https://streams.spec.whatwg.org/#tee-a-readable-stream) the current readable stream, returning a
two-element array containing the two resulting branches as
new `ReadableStream` instances.

This is useful for allowing two readers to read a stream sequentially or simultaneously,
perhaps at different speeds.
For example, you might do this in a ServiceWorker if you want to fetch
a response from the server and stream it to the browser, but also stream it to the
ServiceWorker cache. Since a response body cannot be consumed more than once, you'd need
two copies to do this.

A teed stream will partially signal backpressure at the rate of the _faster_ consumer
of the two `ReadableStream` branches,
and unread data is enqueued internally on the slower consumed `ReadableStream`
without any limit or backpressure.
That is, when _both_ branches have an unread element in their internal queue,
then the original `ReadableStream`'s controller's internal queue will start to fill up,
and once its `ReadableStreamDefaultController.desiredSize", "desiredSize` ≤ 0
or byte stream controller `ReadableByteStreamController.desiredSize", "desiredSize` ≤ 0,
then the controller will stop calling `pull(controller)` on the
underlying source passed to `ReadableStream.ReadableStream", "new ReadableStream()`.
If only one branch is consumed, then the entire body will be enqueued in memory.
Therefore, you should not use the built-in `tee()` to read very large streams
in parallel at different speeds.
Instead, search for an implementation that fully backpressures
to the speed of the _slower_ consumed branch.

To cancel the stream you then need to cancel both resulting branches. Teeing a stream
will generally lock it for the duration, preventing other readers from locking it.

## Syntax

```js
tee()
```

### Parameters

None.

### Return value

An `Array` containing two `ReadableStream` instances.

### Exceptions

- `TypeError`
  - : Thrown if the source stream is not a `ReadableStream`.
