Strophe.js Connection Class — Full API Reference

new Strophe.Connection(service: string, options?: ConnectionOptions)

// BOSH connection
const conn = new Strophe.Connection("https://xmpp.example.com/http-bind/");

// WebSocket connection
const conn = new Strophe.Connection("wss://xmpp.example.com/xmpp-websocket/");

// Relative path (protocol resolved from the current page)
const conn = new Strophe.Connection("/http-bind/", { keepalive: true });

connect(
  jid: string,
  pass: string | Password,
  callback?: ConnectCallback,
  wait?: number,
  hold?: number,
  route?: string,
  authcid?: string,
  disconnection_timeout?: number
): void

attach(
  jid: string | (() => void),
  sid?: string,
  rid?: number,
  callback?: ConnectCallback,
  wait?: number,
  hold?: number,
  wind?: number
): void

// Tokens typically come from a server-side auth endpoint
const { jid, sid, rid } = await fetch("/api/xmpp-session").then(r => r.json());

const conn = new Strophe.Connection("https://xmpp.example.com/http-bind/");
conn.attach(jid, sid, rid, onConnect);

restore(
  jid?: string,
  callback?: ConnectCallback,
  wait?: number,
  hold?: number,
  wind?: number
): void

const conn = new Strophe.Connection("/http-bind/", { keepalive: true });

conn.restore("alice@example.com", (status) => {
  if (status === Strophe.Status.CONNECTED) {
    console.log("Session restored!");
  } else if (status === Strophe.Status.CONNFAIL) {
    // No cached session — fall back to a normal connect
    conn.connect("alice@example.com", password, onConnect);
  }
});

disconnect(reason?: string): void

conn.disconnect("user initiated logout");

flush(): void

conn.send($msg({ to: "bob@example.com" }).c("body").t("Hello"));
conn.send($msg({ to: "carol@example.com" }).c("body").t("Hi"));
conn.flush(); // both messages sent immediately

pause(): void

conn.pause();
// Queue up many stanzas without triggering individual network requests
for (const msg of messages) {
  conn.send(msg);
}
conn.resume(); // All queued stanzas are sent in one or a few requests

resume(): void

bind(): void

const conn = new Strophe.Connection("/http-bind/", {
  explicitResourceBinding: true,
});

conn.connect("alice@example.com", password, (status) => {
  if (status === Strophe.Status.BINDREQUIRED) {
    // Set up XEP-0198 Stream Management before binding
    setupStreamManagement(conn);
    conn.bind();
  }
});

send(stanza: Element | Builder | (Element | Builder)[]): void

// Using a Builder (recommended)
conn.send(
  $msg({ to: "bob@example.com", type: "chat" })
    .c("body").t("Hello, Bob!")
);

// Using a raw Element
const msg = document.createElementNS("jabber:client", "message");
msg.setAttribute("to", "bob@example.com");
conn.send(msg);

// Sending an array of stanzas
conn.send([
  $pres().c("show").t("away"),
  $msg({ to: "bob@example.com" }).c("body").t("BRB"),
]);

sendIQ(
  stanza: Element | Builder,
  callback?: (stanza: Element) => void,
  errback?: (stanza: Element | null) => void,
  timeout?: number
): string

sendPresence(
  stanza: Element | Builder,
  callback?: (stanza: Element) => void,
  errback?: (stanza: Element | null) => void,
  timeout?: number
): string

// Send initial available presence
conn.sendPresence($pres());

// Leave a MUC room and wait for the server echo
conn.sendPresence(
  $pres({ to: "room@conference.example.com/Nick", type: "unavailable" }),
  () => console.log("Left the room"),
  (err) => console.error("Error leaving room:", err),
  3000
);

addHandler(
  handler: (stanza: Element) => boolean,
  ns: string | null,
  name: string | null,
  type: string | string[] | null,
  id?: string | null,
  from?: string | null,
  options?: HandlerOptions
): Handler

addTimedHandler(period: number, handler: () => boolean): TimedHandler

// Send a keepalive presence every 60 seconds
const pingRef = conn.addTimedHandler(60_000, () => {
  conn.send($pres());
  return true; // keep running
});

// Cancel it later
conn.deleteTimedHandler(pingRef);

deleteHandler(handRef: Handler): void

const ref = conn.addHandler(onMessage, null, "message", "chat");
// … later …
conn.deleteHandler(ref);

deleteTimedHandler(handRef: TimedHandler): void

const ref = conn.addTimedHandler(5000, pollServer);
// … later …
conn.deleteTimedHandler(ref);

xmlInput(elem: Node | MessageEvent): void

conn.xmlInput = (elem) => {
  console.log("IN:", new XMLSerializer().serializeToString(elem));
};

xmlOutput(elem: Element): void

conn.xmlOutput = (elem) => {
  console.log("OUT:", new XMLSerializer().serializeToString(elem));
};

rawInput(data: string): void

conn.rawInput = (data) => console.log("RAW IN:", data);

rawOutput(data: string): void

conn.rawOutput = (data) => console.log("RAW OUT:", data);

static addConnectionPlugin(name: string, ptype: object): void

const MyPlugin = {
  init(conn) {
    this._conn = conn;
    conn.addHandler(this._onMessage.bind(this), null, "message");
  },
  _onMessage(stanza) {
    console.log("Plugin received message:", stanza);
    return true;
  },
  sendCustomStanza() {
    this._conn.send(
      $msg({ to: "server.example.com" }).c("x", { xmlns: "my:plugin:ns" })
    );
  },
};

Strophe.Connection.addConnectionPlugin("myPlugin", MyPlugin);

// Now every new Connection has `conn.myPlugin`
const conn = new Strophe.Connection("/http-bind/");
conn.connect("alice@example.com", "pass", () => {
  conn.myPlugin.sendCustomStanza();
});