How to get a live price snapshot in bloomberg?

Question

I am looking to get a live price snapshot from Bloomberg .Net API 3 with C#.

I can see from the samples how to get historical prices or subscribe to data, but I cannot find the correct request to get an order book snapshot, ie Bid/Ask/Last trade Price and Quantities.

For an intraday tick I would do something like this:

Service refDataService = d_session.GetService("//blp/refdata");
// create intraday tick request
Request request = refDataService.CreateRequest("IntradayTickRequest");
// set request parameters
request.Set("includeConditionCodes", checkBoxIncludeConditionCode.Checked);
request.Set("includeExchangeCodes", checkBoxIncludeExchangeCode.Checked);
Element eventTypes = request.GetElement("eventTypes");
eventTypes.AppendValue("TRADE");
eventTypes.AppendValue("BID");
eventTypes.AppendValue("ASK");
request.Set("security", d_requestSecurity);
request.Set("startDateTime", new BDateTime(startDate.Year, startDate.Month,
             startDate.Day,startDate.Hour, startDate.Minute, startDate.Second, 0));
request.Set("endDateTime", new BDateTime(endDate.Year, endDate.Month, endDate.Day,
             endDate.Hour, endDate.Minute, endDate.Second, 0));

Is there a different, live snapshot request?

Answer 1

Minimally adapted from the example that comes with the API:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Bloomberglp.Blpapi;

namespace BbServerApiTool
{
    public class GetFields : GetBloombergFields
    {
        private static readonly Name EXCEPTIONS = new Name("exceptions");
        private static readonly Name FIELD_ID = new Name("fieldId");
        private static readonly Name REASON = new Name("reason");
        private static readonly Name CATEGORY = new Name("category");
        private static readonly Name DESCRIPTION = new Name("description");
        private static readonly Name ERROR_CODE = new Name("errorCode");
        private static readonly Name SOURCE = new Name("source");
        private static readonly Name SECURITY_ERROR = new Name("securityError");
        private static readonly Name MESSAGE = new Name("message");
        private static readonly Name RESPONSE_ERROR = new Name("responseError");
        private static readonly Name SECURITY_DATA = new Name("securityData");
        private static readonly Name FIELD_EXCEPTIONS = new Name("fieldExceptions");
        private static readonly Name ERROR_INFO = new Name("errorInfo");

        public override List<List<string>> GetBbFields(string[] tickers, string[] fieldsParam)
        {
            string serverHost = System.Configuration.ConfigurationManager.AppSettings["Host"];
            int serverPort = Int32.Parse(System.Configuration.ConfigurationManager.AppSettings["Port"]);

            var sessionOptions = new SessionOptions {ServerHost = serverHost, ServerPort = serverPort};

            var session = new Session(sessionOptions);
            session.Start();
            session.OpenService("//blp/refdata");
            Service refDataService = session.GetService("//blp/refdata");
            Request request = refDataService.CreateRequest("ReferenceDataRequest");
            Element securities = request.GetElement("securities");
            Element fields = request.GetElement("fields");
            request.Set("returnEids", true);

            foreach (var ticker in tickers)
            {
                securities.AppendValue(ticker);
            }

            foreach (var field in fieldsParam)
            {
                fields.AppendValue(field);
            }

            var cID = new CorrelationID(1);
            session.Cancel(cID);
            Results = new List<List<string>>();
            session.SendRequest(request, cID);

            while (true)
            {
                Event eventObj = session.NextEvent();
                processEvent(eventObj, session, fieldsParam);
                if (eventObj.Type == Event.EventType.RESPONSE)
                {
                    return Results;   
                }
            }
        }

        protected override string GetName()
        {
            return "BbServerApiTool";
        }

        private void processEvent(Event eventObj, Session session, string[] fields)
        {
            switch (eventObj.Type)
            {
                case Event.EventType.RESPONSE:
                case Event.EventType.PARTIAL_RESPONSE:
                    processRequestDataEvent(eventObj, session, fields);
                    break;
                default:
                    processMiscEvents(eventObj, session);
                    break;
            }
        }

        private void processMiscEvents(Event eventObj, Session session)
        {
            foreach (Message msg in eventObj.GetMessages())
            {
                switch (msg.MessageType.ToString())
                {
                    case "RequestFailure":
                        Element reason = msg.GetElement(REASON);
                        string message = string.Concat("Error: Source-", reason.GetElementAsString(SOURCE),
                            ", Code-", reason.GetElementAsString(ERROR_CODE), ", category-", reason.GetElementAsString(CATEGORY),
                            ", desc-", reason.GetElementAsString(DESCRIPTION));
                        throw new ArgumentException(message);
                    case "SessionStarted":
                    case "SessionTerminated":
                    case "SessionStopped":
                    case "ServiceOpened":
                    default:
                        break;
                }
            }
        }
        private void processRequestDataEvent(Event eventObj, Session session, string[] fields)
        {
            foreach (Message msg in eventObj.GetMessages())
            {
                if (msg.MessageType.Equals(Name.GetName("ReferenceDataResponse")))
                {
                    Element secDataArray = msg.GetElement(SECURITY_DATA);
                    int numberOfSecurities = secDataArray.NumValues;
                    for (int index = 0; index < numberOfSecurities; index++)
                    {
                        Element secData = secDataArray.GetValueAsElement(index);
                        Element fieldData = secData.GetElement("fieldData");

                        if (secData.HasElement(FIELD_EXCEPTIONS))
                        {
                            // process error
                            Element error = secData.GetElement(FIELD_EXCEPTIONS);
                            if (error.Elements.Count() > 0)
                            {
                                Element errorException = error.GetValueAsElement(0);
                                Element errorInfo = errorException.GetElement(ERROR_INFO);
                                string message = errorInfo.GetElementAsString(MESSAGE);
                                throw new ArgumentException(message);
                            }
                        }

                        var list = new List<string> { secData.GetElement("security").GetValueAsString() };
                        if (secData.HasElement(SECURITY_ERROR))
                        {
                            Element error = secData.GetElement(SECURITY_ERROR);
                            string errorMessage = error.GetElementAsString(MESSAGE);
                            //                            throw new ArgumentException(errorMessage);
                            //TODO Log
                            logger.WriteLine("Couldn't get a value for " + secData.GetElement("security").GetValueAsString());
                            foreach (var field in fields)
                            {
                                list.Add("N/A");
                            }
                        }
                        else
                        {
                            foreach (var field in fields)
                            {
                                Element item = fieldData.GetElement(field);
                                list.Add(item.IsNull ? "N/A" : item.GetValueAsString());
                            }
                        }
                        Results.Add(list);
                    }
                }
            }
        }
    }
}

Answer 2

If you want to ensure absolutely live pricing, you would probably use the subscription service api (//blp/mktdata), which will also return the price with the exact time of the last trade tagged to it.

There is a good example of this in the Developer's Guide available via a Bloomberg Terminal in appendix C.2 (The subscription paradigm one).

Answer 3

It appears there is no specific Bloomberg request for a 'Live Snapshot' of the order book. The other methods are obviously documented in the examples, but it seems Bloomberg do not give this in their .Net API.

There are reference data requests which seem to be the closest to a snapshot type of query, but there is no documentation on the latency in updating these variables. The name 'reference' does not inspire great confidence in something sounding like a real time request.

A subscription is the alternative method to a snapshot type of request and can be superior in many applications. With a subscription, updates to the order book are streamed live to your socket. The drawback with this approach is that you need the internal architecture to support it and also you may have to wait for an indeterminate length of time to see any activity in some markets.

With this in mind, I think a trial and error approach is best, and working with another data provider could be more fruitful.