Real-Time Crypto Events
via WebSocket

import websockets
import asyncio
import json

async def connect_websocket():
    async with websockets.connect('wss://ws.anypayx.com') as ws:
        while True:
            data = await ws.recv()
            event = json.loads(data)
            print('Received:', event)

asyncio.get_event_loop().run_until_complete(connect_websocket())

const WebSocket = require('ws')

const ws = new WebSocket('wss://ws.anypayx.com')

ws.on('open', () => {
  console.log('Connected to AnyPay WebSocket')
})

ws.on('message', (data) => {
  const event = JSON.parse(data)
  console.log('Received:', event)
})

ws.on('error', (error) => {
  console.error('WebSocket error:', error)
})

ws.on('close', () => {
  console.log('Disconnected from WebSocket')
})

package main

import (
    "fmt"
    "log"
    "encoding/json"
    "github.com/gorilla/websocket"
)

func main() {
    c, _, err := websocket.DefaultDialer.Dial("wss://ws.anypayx.com", nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer c.Close()

    fmt.Println("Connected to AnyPay WebSocket")

    for {
        _, message, err := c.ReadMessage()
        if err != nil {
            log.Println("read:", err)
            return
        }
        
        var data interface{}
        json.Unmarshal(message, &data)
        fmt.Printf("Received: %+v\n", data)
    }
}

use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
use futures_util::StreamExt;
use url::Url;
use serde_json::Value;

#[tokio::main]
async fn main() {
    let url = Url::parse("wss://ws.anypayx.com").unwrap();
    
    let (ws_stream, _) = connect_async(url).await.expect("Failed to connect");
    println!("Connected to AnyPay WebSocket");
    
    let (_, mut read) = ws_stream.split();
    
    while let Some(message) = read.next().await {
        match message {
            Ok(Message::Text(text)) => {
                let data: Value = serde_json::from_str(&text).unwrap();
                println!("Received: {:?}", data);
            }
            Err(e) => println!("Error: {}", e),
            _ => (),
        }
    }
}

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

class Program
{
    static async Task Main(string[] args)
    {
        using (ClientWebSocket ws = new ClientWebSocket())
        {
            await ws.ConnectAsync(new Uri("wss://ws.anypayx.com"), CancellationToken.None);
            Console.WriteLine("Connected to AnyPay WebSocket");

            var buffer = new byte[1024 * 4];
            while (ws.State == WebSocketState.Open)
            {
                var result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                    var data = JObject.Parse(message);
                    Console.WriteLine($"Received: {data}");
                }
            }
        }
    }
}

import java.net.URI;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;

public class AnyPayWebSocket extends WebSocketClient {
    
    public AnyPayWebSocket() {
        super(new URI("wss://ws.anypayx.com"));
    }

    @Override
    public void onOpen(ServerHandshake handshake) {
        System.out.println("Connected to AnyPay WebSocket");
    }

    @Override
    public void onMessage(String message) {
        JSONObject data = new JSONObject(message);
        System.out.println("Received: " + data.toString());
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        System.out.println("Disconnected from WebSocket");
    }

    @Override
    public void onError(Exception ex) {
        System.err.println("WebSocket error: " + ex.getMessage());
    }

    public static void main(String[] args) {
        AnyPayWebSocket client = new AnyPayWebSocket();
        client.connect();
    }
}