Conectar vía WebSocket

curl -v --include \
  --header "Connection: Upgrade" \
  --header "Upgrade: websocket" \
  --header "Sec-WebSocket-Key: $(openssl rand -base64 16)" \
  --header "Sec-WebSocket-Version: 13" \
  --header "token: $Token_Instance" \
  "https://ryzeapi.cloud/ws/$Instance_Name"

// Raw handshake via Node (no WS libs) - inspection only
import https from "node:https";
import crypto from "node:crypto";

const req = https.request({
  hostname: "ryzeapi.cloud",
  path:     `/ws/${process.env.Instance_Name}`,
  method:   "GET",
  headers: {
    "Connection":            "Upgrade",
    "Upgrade":               "websocket",
    "Sec-WebSocket-Key":     crypto.randomBytes(16).toString("base64"),
    "Sec-WebSocket-Version": "13",
    "token":                 process.env.Token_Instance
  }
});
req.on("upgrade", (res, socket) => {
  console.log("Upgraded:", res.statusCode);
  socket.end();
});
req.end();

# Raw handshake - inspection only
import os, base64, secrets, http.client

conn = http.client.HTTPSConnection("ryzeapi.cloud")
conn.request(
    "GET",
    f"/ws/{os.environ['Instance_Name']}",
    headers={
        "Connection":            "Upgrade",
        "Upgrade":               "websocket",
        "Sec-WebSocket-Key":     base64.b64encode(secrets.token_bytes(16)).decode(),
        "Sec-WebSocket-Version": "13",
        "token":                 os.environ["Token_Instance"]
    }
)
resp = conn.getresponse()
print("Status:", resp.status)

package main

import (
    "crypto/rand"
    "encoding/base64"
    "log"
    "net/http"
    "os"
)

func main() {
    key := make([]byte, 16)
    rand.Read(key)
    req, _ := http.NewRequest("GET", "https://ryzeapi.cloud/ws/"+os.Getenv("Instance_Name"), nil)
    req.Header.Set("Connection", "Upgrade")
    req.Header.Set("Upgrade", "websocket")
    req.Header.Set("Sec-WebSocket-Key", base64.StdEncoding.EncodeToString(key))
    req.Header.Set("Sec-WebSocket-Version", "13")
    req.Header.Set("token", os.Getenv("Token_Instance"))
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Status:", resp.Status)
}

# npm i -g wscat
wscat -c "wss://api.example.com/ws/$Instance_Name?token=$Token_Instance"

// Native WebSocket client (Node.js 22+ or browser)
const ws = new WebSocket(`wss://api.example.com/ws/${process.env.Instance_Name}?token=${process.env.Token_Instance}`);
ws.addEventListener("message", (ev) => console.log(ev.data));

import asyncio, os, websockets

async def main():
    url = f"wss://api.example.com/ws/{os.environ['Instance_Name']}?token={os.environ['Token_Instance']}"
    async with websockets.connect(url) as ws:
        async for raw in ws:
            print(raw)

asyncio.run(main())

package main

import (
    "log"
    "os"
    "github.com/gorilla/websocket"
)

func main() {
    url := "wss://api.example.com/ws/" + os.Getenv("Instance_Name") + "?token=" + os.Getenv("Token_Instance")
    c, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer c.Close()
    for {
        _, msg, err := c.ReadMessage()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("%s", msg)
    }
}