use futures_util::{SinkExt, StreamExt};
use serde_json::json;
use tokio_tungstenite::connect_async;
use url::Url;

#[tokio::main]
async fn main() {
    let url = "wss://finai.synlabs.pro/api/v1/markets/predictions?api_key=YOUR_KEY";
    let (ws_stream, _) = connect_async(Url::parse(url).unwrap()).await.expect("Failed to connect");
    let (mut write, mut read) = ws_stream.split();

    // Wait for Auth Success
    if let Some(msg) = read.next().await {
        println!("Auth: {}", msg.unwrap());
    }

    // Subscribe
    let subscribe_msg = json!({
        "action": "subscribe",
        "symbol": "eurusd",
        "timeframe": "1m"
    });
    write.send(subscribe_msg.to_string().into()).await.unwrap();

    // Listen
    while let Some(msg) = read.next().await {
        let data = msg.unwrap();
        if data.is_text() {
             let v: serde_json::Value = serde_json::from_str(data.to_text().unwrap()).unwrap();
             if v["type"] == "prediction" {
                 println!("📊 {} {}", v["symbol"], v["timeframe"]);
                 println!("{}", serde_json::to_string_pretty(&v).unwrap());
             }
        }
    }
}Rust

// Minimal example structure using Boost.Beast
#include <boost/beast/core.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/beast/websocket/ssl.hpp>
#include <boost/asio/connect.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <iostream>
#include <string>
#include <nlohmann/json.hpp> // Requires nlohmann/json

namespace beast = boost::beast;
namespace http = beast::http;
namespace websocket = beast::websocket;
namespace net = boost::asio;
namespace ssl = boost::asio::ssl;
using tcp = boost::asio::ip::tcp;
using json = nlohmann::json;

int main() {
    try {
        auto const host = "finai.synlabs.pro";
        auto const port = "443";
        auto const target = "/api/v1/markets/predictions?api_key=YOUR_KEY";

        net::io_context ioc;
        ssl::context ctx{ssl::context::tlsv12_client};
        ctx.set_default_verify_paths();

        tcp::resolver resolver{ioc};
        websocket::stream> ws{ioc, ctx};

        auto const results = resolver.resolve(host, port);
        net::connect(beast::get_lowest_layer(ws), results);
        ws.next_layer().handshake(ssl::stream_base::client);
        ws.handshake(host, target);

        // Auth response
        beast::flat_buffer buffer;
        ws.read(buffer);
        std::cout << "Auth: " << beast::make_printable(buffer.data()) << std::endl;

        // Subscribe
        json sub = {
            {"action", "subscribe"},
            {"symbol", "eurusd"},
            {"timeframe", "1m"}
        };
        ws.write(net::buffer(sub.dump()));

        // Loop
        while(true) {
            buffer.consume(buffer.size());
            ws.read(buffer);
            std::cout << beast::make_printable(buffer.data()) << std::endl;
        }
    }
    catch(std::exception const& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}C++ (Boost)