Nimble Polyglot Microcosm

    TypeScript icon, indicating that this package has built-in type declarations

    4.4.1 • Public • Published

    Slite's fork of Reconnecting WebSocket

    This is the same as but with

    WebSocket that will automatically reconnect if the connection is closed.


    • WebSocket API compatible (same interface, Level0 and Level2 event model)
    • Fully configurable
    • Multi-platform (Web, ServiceWorkers, Node.js, React Native)
    • Dependency free (does not depend on Window, DOM or any EventEmitter library)
    • Handle connection timeouts
    • Allows changing server URL between reconnections
    • Buffering. Will send accumulated messages on open
    • Multiple builds available (see dist folder)
    • Debug mode


    npm install --save reconnecting-websocket


    Compatible with WebSocket Browser API

    So this documentation should be valid: MDN WebSocket API.

    Ping me if you find any problems. Or, even better, write a test for your case and make a pull request :)

    Simple usage

    import ReconnectingWebSocket from 'reconnecting-websocket';
    const rws = new ReconnectingWebSocket('ws://');
    rws.addEventListener('open', () => {

    Update URL

    The url parameter will be resolved before connecting, possible types:

    • string
    • () => string
    • () => Promise<string>
    import ReconnectingWebSocket from 'reconnecting-websocket';
    const urls = ['ws://', 'ws://', 'ws://'];
    let urlIndex = 0;
    // round robin url provider
    const urlProvider = () => urls[urlIndex++ % urls.length];
    const rws = new ReconnectingWebSocket(urlProvider);
    import ReconnectingWebSocket from 'reconnecting-websocket';
    // async url provider
    const urlProvider = async () => {
        const token = await getSessionToken();
        return `wss://${token}`;
    const rws = new ReconnectingWebSocket(urlProvider);


    Sample with custom options

    import ReconnectingWebSocket from 'reconnecting-websocket';
    import WS from 'ws';
    const options = {
        WebSocket: WS, // custom WebSocket constructor
        connectionTimeout: 1000,
        maxRetries: 10,
    const rws = new ReconnectingWebSocket('ws://', [], options);

    Available options

    type Options = {
        WebSocket?: any; // WebSocket constructor, if none provided, defaults to global WebSocket
        maxReconnectionDelay?: number; // max delay in ms between reconnections
        minReconnectionDelay?: number; // min delay in ms between reconnections
        reconnectionDelayGrowFactor?: number; // how fast the reconnection delay grows
        minUptime?: number; // min time in ms to consider connection as stable
        connectionTimeout?: number; // retry connect if not connected after this time, in ms
        maxRetries?: number; // maximum number of retries
        maxEnqueuedMessages?: number; // maximum number of messages to buffer until reconnection
        startClosed?: boolean; // start websocket in CLOSED state, call `.reconnect()` to connect
        retryURL: boolean; // retry URL provider request if it fails (it follows the same logic as WebSocket retries)
        debug?: boolean; // enables debug output

    Default values

    WebSocket: undefined,
    maxReconnectionDelay: 10000,
    minReconnectionDelay: 1000 + Math.random() * 4000,
    reconnectionDelayGrowFactor: 1.3,
    minUptime: 5000,
    connectionTimeout: 4000,
    maxRetries: Infinity,
    maxEnqueuedMessages: Infinity,
    startClosed: false,
    retryURL: false,
    debug: false,



    constructor(url: UrlProvider, protocols?: string | string[], options?: Options)
    close(code?: number, reason?: string)
    reconnect(code?: number, reason?: string)
    send(data: string | ArrayBuffer | Blob | ArrayBufferView)
    addEventListener(type: 'open' | 'close' | 'message' | 'error', listener: EventListener)
    removeEventListener(type:  'open' | 'close' | 'message' | 'error', listener: EventListener)


    More info

    binaryType: string;
    bufferedAmount: number;
    extensions: string;
    onclose: EventListener;
    onerror: EventListener;
    onmessage: EventListener;
    onopen: EventListener;
    protocol: string;
    readyState: number;
    url: string;
    retryCount: number;


    CONNECTING 0 The connection is not yet open.
    OPEN       1 The connection is open and ready to communicate.
    CLOSING    2 The connection is in the process of closing.
    CLOSED     3 The connection is closed or couldn't be opened.


    Read here




    npm i @slite/reconnecting-websocket

    DownloadsWeekly Downloads






    Unpacked Size

    141 kB

    Total Files


    Last publish


    • dqms
    • accounts-dev-slite
    • calyhre
    • arnaudrinquin
    • prenaudin
    • shahor
    • antoineduban
    • julienr2
    • guillaumemorin
    • christophepas
    • antoinelyset
    • d34thwings
    • jasonphillips
    • bitphinix
    • agix
    • alisonsayarath
    • emanuelpinho