Fair Market Value

# Connect to the websocket
npx wscat -c wss://business.massive.com/options

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

# Subscribe to the topic
{"action":"subscribe", "params":"FMV.O:SPY251219C00650000"}

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.Business,
	market=Market.Options
	)

# FMV
client.subscribe("FMV.O:SPY251219C00650000")
# client.subscribe("FMV.*")  # all options
# client.subscribe("FMV.O:SPY241220P00720000")

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

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.BusinessFeed,
		Market: massivews.Options,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer c.Close()

	// FMV
	_ = c.Subscribe(massivews.BusinessFairMarketValue, "O:SPY251219C00650000")
	//_ = c.Subscribe(massivews.BusinessFairMarketValue, "*") // 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) {
			case models.FairMarketValue:
				log.Printf("FMV: %+v\n", out)
			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://business.massive.com').options();

// 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 Fair Market Value channel for O:SPY251219C00650000');
		ws.send(JSON.stringify({"action":"subscribe", "params":"FMV.O:SPY251219C00650000"}));
	}

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

package com.massive.kotlin.sdk.sample

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

suspend fun stocksWebsocketSample(massiveKey: String) {
    val websocketClient = MassiveWebSocketClient(
        massiveKey,
        Feed.BusinessFeed,
        Market.BusinessOptions,
        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.BusinessMessage.FairMarketValue, "O:SPY251219C00650000"),
        //MassiveWebSocketSubscription(MassiveWebSocketChannel.BusinessMessage.FairMarketValue, "*"),
    )

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