Aggregates (Per Minute)

# Connect to the websocket
npx wscat -c wss://delayed.massive.com/futures

# Authenticate
{"action":"auth","params":"YOUR_API_KEY"}

# Subscribe to the topic
{"action":"subscribe", "params":"AM.*"}

from massive import WebSocketClient
from massive.websocket.models import WebSocketMessage, Feed, Market
from typing import List

client = WebSocketClient(
	api_key="YOUR_API_KEY",
	feed=Feed.Delayed,
	market=Market.Futures
	)

# aggregates (per minute)
client.subscribe("AM.*")

def handle_msg(msgs: List[WebSocketMessage]):
    for m in msgs:
        print(m)

# print messages
client.run(handle_msg)

package main

import (
	"log"
	"os"
	"os/signal"

	massivews "github.com/massive-com/client-go/v2/websocket"
)

func main() {

	c, err := massivews.New(massivews.Config{
		APIKey: "YOUR_API_KEY",
		Feed:   massivews.Delayed,
		Market: massivews.Futures,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer c.Close()

	// aggregates
	_ = c.Subscribe(massivews.FuturesMinAggs, "*")

	if err := c.Connect(); err != nil {
		log.Printf("Error connecting: %v\n", err)
		return
	}

	sigint := make(chan os.Signal, 1)
	signal.Notify(sigint, os.Interrupt)

	for {
		select {
		case <-sigint:
			return
		case <-c.Error():
			return
		case out, more := <-c.Output():
			if !more {
				return
			}
			switch out.(type) {
			default:
				log.Printf("Unknown: %+v\n", out)
			}
		}
	}
}

import { websocketClient } from "@massive.com/client-js";

// create a websocket client using the massive client-js library
const ws  = websocketClient('YOUR_API_KEY', 'wss://delayed.massive.com').futures();
// business users must pass in an exchange as a third parameter (ex: cme, cbot, comex, nymex)
// const ws  = websocketClient('YOUR_API_KEY', 'wss://delayed.massive.com', 'cme').futures();

// register a handler to log errors
ws.onerror = (err) => console.log('Failed to connect', err);

// register a handler to log info if websocket closes
ws.onclose = (code, reason) => console.log('Connection closed', code, reason);

// register a handler when messages are received
ws.onmessage = (msg) => {
	// parse the data from the message
	const parsedMessage = JSON.parse(msg.data);

	// wait until the message saying authentication was successful, then subscribe to a channel
	if (parsedMessage[0].ev === 'status' && parsedMessage[0].status === 'auth_success') {
		console.log('Subscribing to the minute aggregates channel for *');
		ws.send(JSON.stringify({"action":"subscribe", "params":"AM.*"}));
	}

	console.log('Message received:', parsedMessage);
}

package com.massive.kotlin.sdk.sample

import com.massive.kotlin.sdk.websocket.*
import kotlinx.coroutines.delay

suspend fun futuresWebsocketSample(massiveKey: String) {
    val websocketClient = MassiveWebSocketClient(
        massiveKey,
        Feed.Delayed,
        Market.Futures,
        object : MassiveWebSocketListener {
            override fun onAuthenticated(client: MassiveWebSocketClient) {
                println("Connected!")
            }

            override fun onReceive(
                client: MassiveWebSocketClient,
                message: MassiveWebSocketMessage
            ) {
                when (message) {
                    is MassiveWebSocketMessage.RawMessage -> println(String(message.data))
                    else -> println("Receieved Message: $message")
                }
            }

            override fun onDisconnect(client: MassiveWebSocketClient) {
                println("Disconnected!")
            }

            override fun onError(client: MassiveWebSocketClient, error: Throwable) {
                println("Error: ")
                error.printStackTrace()
            }

        })

    val subscriptions = listOf(
        MassiveWebSocketSubscription(MassiveWebSocketChannel.Futures.AggPerMinute, "*")
        //MassiveWebSocketSubscription(MassiveWebSocketChannel.Futures.AggPerMinute, "*")
    )

    websocketClient.connect()
    websocketClient.subscribe(subscriptions)
    delay(65_000)
    websocketClient.unsubscribe(subscriptions)
    websocketClient.disconnect()
}