Errors

import json
import websocket

def on_message(ws, message):
    msg = json.loads(message)
    if msg.get("type") == "error":
        code = msg.get("error_code")
        print(f"[ERROR] {code}: {msg.get('message')}")
        # basic strategy
        if code == "RateLimited":
            # implement backoff before retrying your last request
            return
        elif code in ("InvalidJSONFormat", "InvalidParameter"):
            # fix your payload; don't auto-retry
            return
        elif code in ("PermissionDenied", "AlreadyAuthenticated"):
            # adjust flow; no retry
            return
        else:
            # ServerError or unknown: small backoff and optional retry
            return
    else:
        print("OK:", msg)

import WebSocket from "ws";

const ws = new WebSocket("wss://trade.qfex.com?api_key=YOUR_API_KEY");

ws.on("message", (raw) => {
  const msg = JSON.parse(raw.toString());
  if (msg.type === "error") {
    const { error_code, message } = msg;
    console.error(`[ERROR] ${error_code}: ${message || ""}`);

    switch (error_code) {
      case "RateLimited":
        // schedule retry w/ backoff
        break;
      case "InvalidJSONFormat":
      case "InvalidParameter":
        // fix payload, do not blind-retry
        break;
      case "PermissionDenied":
      case "AlreadyAuthenticated":
        // update client state/flow
        break;
      default:
        // transient server error: optional retry with jitter
        break;
    }
    return;
  }

  // handle normal messages…
});

type ErrorFrame struct {
    Type            string          `json:"type"`
    ErrorCode       string          `json:"error_code"`
    Message         *string         `json:"message,omitempty"`
    IncomingMessage json.RawMessage `json:"incoming_message,omitempty"`
}

func handleMessage(raw []byte) {
    // peek at "type"
    var meta struct{ Type string `json:"type"` }
    if err := json.Unmarshal(raw, &meta); err != nil { return }

    if meta.Type == "error" {
        var ef ErrorFrame
        if err := json.Unmarshal(raw, &ef); err == nil {
            log.Printf("[ERROR] %s: %s", ef.ErrorCode, deref(ef.Message))
            // handle per code...
        }
        return
    }

    // normal flow...
}