Aggregates (Per Second)

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

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

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

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.Indices
	)

# aggregates (per second)
client.subscribe("A.*")
# client.subscribe("A.*") # all aggregates
# client.subscribe("A.I:SPX")  # Standard & Poor's 500
# client.subscribe("A.I:DJI")  # Dow Jones Industrial Average
# client.subscribe("A.I:NDX")  # Nasdaq-100
# client.subscribe("A.I:VIX")  # Volatility Index

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"
	//"github.com/massive-com/client-go/v2/websocket/models"
)

func main() {

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

	// aggregates
	_ = c.Subscribe(massivews.IndexSecAggs, "*")
	//_ = c.Subscribe(massivews.IndexSecAggs, "*") // all tickers

	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').indices();

// 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 second aggregates channel for *');
		ws.send(JSON.stringify({"action":"subscribe", "params":"A.*"}));
	}

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

package com.massive.kotlin.sdk.sample

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

suspend fun indicesWebsocketSample(massiveKey: String) {
    val websocketClient = MassiveWebSocketClient(
        massiveKey,
        Feed.Delayed,
        Market.Indices,
        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.Indices.AggPerSecond, "*")
        //MassiveWebSocketSubscription(MassiveWebSocketChannel.Indices.AggPerSecond, "I:SPX")
    )

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