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();

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

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

    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 <nlohmann/json.hpp>

namespace beast = boost::beast;
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<beast::ssl_stream<tcp::socket>> 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);

        beast::flat_buffer buffer;
        ws.read(buffer); // auth response

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

        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)