{
  	// The type of operation
	"type": "connection",
   	// The status of the operation
	"status": "ready",
	"data": {
     	// Your socket id for debugging purposes
		"id": "9nqpzwmwh86"
	}
}

{
	"type": "subscribe",
	"event": "ask.created",
}

{
  "type": "subscribe",
  "event": "collection.updated",
  "filters": {
    "id": "0xd774557b647330c91bf44cfeab205095f7e6c367"
    // can optionally filter by multiple tags at once by using an array
    // "contract": [
    //		"0x0000c3Caa36E2d9A8CD5269C976eDe05018f0000",
    //		"0x0000c4Caa36E2d9A8CD5269C976eDe05018f0000"
    // ]
  }
}

{
  "type": "subscribe",
  "event": "bid.created",
  "exclude": {
    "source": ["opensea.io"]
  }
}

{
  "type": "subscribe",
  "event": "token.updated",
  "changed": "collection_id"
}

{
	"type": "subscribe",
	"status": "success",
	"data": {
		"event": "ask.created",
    	// Blank object if no filter is passed
		"filters": {
			"contract": "0x404e739c9d383efc36d3ee85fdceed53212104b2"
		}
	}
}

{
	"type": "unsubscribe",
	"event": "ask.created",
  	// Tags to filter events by, leave blank to not filter by any tags
 	"filters": {
   		"contract": "0x0000c3Caa36E2d9A8CD5269C976eDe05018f0000"
 	 }
}

{
	"type": "unsubscribe",
	"status": "success",
	"data": {
		"event": "top-bid.changed"
	}
}

const ws = require('ws');

// You can get your API key from https://reservoir.tools
const YOUR_API_KEY = '';

// sepolia: wss://ws.ws-sepolia.reservoir.tools
const wss = new ws(`wss://ws.reservoir.tools?api_key=${YOUR_API_KEY}`);

wss.on('open', function open() {
    console.log('Connected to Reservoir');

    wss.on('message', function incoming(data) {
        console.log('Message received: ', JSON.stringify(JSON.parse(data)));

        // When the connection is ready, subscribe to the top-bids event
        if (JSON.parse(data).status === 'ready') {
            console.log('Subscribing');
            wss.send(
                JSON.stringify({
                    type: 'subscribe',
                    event: 'top-bid.changed',
                }),
            );

            // To unsubscribe, send the following message
            // wss.send(
            //     JSON.stringify({
            //         type: 'unsubscribe',
            //         event: 'top-bid.changed',
            //     }),
            // );
        }
    });
});

import asyncio
import json
import websockets

# You can get your API key from https://reservoir.tools
api_key = ''

# sepolia: wss://ws.ws-sepolia.reservoir.tools
wss_url = f'wss://ws.reservoir.tools?api_key={api_key}'

async def subscribe_top_bids():
    async with websockets.connect(wss_url) as websocket:
        print('Connected to Reservoir')

        async for data in websocket:
            message = json.loads(data)
            print('Message received:', message)

            if message.get('status') == 'ready':
                print('Subscribing')
                await websocket.send(
                    json.dumps({
                        'type': 'subscribe',
                        'event': 'top-bid.changed',
                    }),
                )

                # To unsubscribe, send the following message
                # await websocket.send(
                #     json.dumps({
                #         'type': 'unsubscribe',
                #         'event': 'top-bid.changed',
                #     }),
                # )

asyncio.run(subscribe_top_bids())

package main

import (
  "context"
  "fmt"
  "log"
  "net/http"
  "time"

  "nhooyr.io/websocket"
  "nhooyr.io/websocket/wsjson"
)

// You can get your API key from https://reservoir.tools
const apiKey = ""

func main() {
  ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
  defer cancel()

  // sepolia: wss://ws.ws-sepolia.reservoir.tools
  url := fmt.Sprintf("wss://ws.reservoir.tools?api_key=%s", apiKey)
  conn, _, err := websocket.Dial(ctx, url, &websocket.DialOptions{
    HTTPHeader: http.Header{
      "Authorization": []string{fmt.Sprintf("Bearer %s", apiKey)},
    },
  })
  if err != nil {
    log.Fatal("Error connecting to Reservoir: ", err)
  }
  defer conn.Close(websocket.StatusInternalError, "the sky is falling")

  fmt.Println("Connected to Reservoir")

  var message map[string]interface{}
  for {
    err := wsjson.Read(ctx, conn, &message)
    if err != nil {
      log.Println("Error reading message: ", err)
      break
    }

    fmt.Println("Message received: ", message)

    // When the connection is ready, subscribe to the top-bids event
    if message["status"] == "ready" {
      fmt.Println("Subscribing")
      err = wsjson.Write(ctx, conn, map[string]interface{}{
        "type":  "subscribe",
        "event": "top-bid.changed",
      })
      if err != nil {
        log.Println("Error subscribing: ", err)
        break
      }

      // To unsubscribe, send the following message
      // err = wsjson.Write(ctx, conn, map[string]interface{}{
      //     "type":    "unsubscribe",
      //     "event": "top-bid.changed",
      // })
      // if err != nil {
      //     log.Println("Error unsubscribing: ", err)
      //     break
      // }
    }
  }
}

use serde_json::json;
use ws::{Builder, CloseCode, Error, Handler, Message, Result, Sender};

struct Client {
    out: Sender,
}

impl Handler for Client {
    fn on_open(&mut self, _: Handshake) -> Result<()> {
        println!("Connected to Reservoir");
        Ok(())
    }

    fn on_message(&mut self, msg: Message) -> Result<()> {
        let message: serde_json::Value = serde_json::from_str(&msg.to_string()).unwrap();
        println!("Message received: {:?}", message);

        if message["status"] == "ready" {
            println!("Subscribing");
            self.out.send(json!({
                "type": "subscribe",
                "event": "top-bid.changed",
            }))?;

            // To unsubscribe, send the following message
            // self.out.send(json!({
            //     "type": "unsubscribe",
            //     "event": "top-bid.changed",
            // }))?;
        }
        Ok(())
    }

    fn on_close(&mut self, code: CloseCode, reason: &str) {
        match code {
            CloseCode::Normal => println!("Connection closed normally"),
            CloseCode::Away => println!("Connection closed because server is going away"),
            _ => println!("Connection closed with code: {:?} for reason: {}", code, reason),
        }
    }

    fn on_error(&mut self, err: Error) {
        println!("Error: {:?}", err);
    }
}

fn main() {
    // You can get your API key from https://reservoir.tools
    let api_key = "";

    // sepolia: wss://ws.ws-sepolia.reservoir.tools
    let url = format!("wss://ws.reservoir.tools?api_key={}", api_key);

    Builder::new()
        .build(|out| Client { out })
        .unwrap()
        .connect(url)
        .unwrap();
}