@teamshooks/mctypea

MConnect TypeA SDK

The official TypeScript/JavaScript client for communicating with the MConnect TypeA Trading API.

MConnect TypeA is a comprehensive trading API that provides capabilities required to build a complete investment and trading platform. Execute orders in real time, manage user portfolio, stream live market data (WebSockets), and more.

Documentation

• MConnect API documentation
• Examples

Requirements

• Node.js v18.0.0+

Installation

Install via npm

npm install mconnecttypea

Getting started with API

import { MConnect } from 'mconnecttypea';

const apiKey = "your_api_key";
const username = "your_username";
const password = "your_password";

const client = new MConnect({ api_key: apiKey });

async function init() {
  try {
    await authenticateUser();
    await getPortfolio();
  } catch (err) {
    console.error(err);
  }
}

async function authenticateUser() {
  try {
    // Step 1: Login (triggers OTP)
    const loginResponse = await client.login({ username, password });
    console.log('Login successful, OTP sent');
    
    // Step 2: Get OTP from user input
    const otp = "123456"; // Get from user input
    
    // Step 3: Generate session with OTP
    const sessionData = await client.generateSession({
      api_key: apiKey,
      request_token: otp,
      checksum: 'W'
    });
    
    client.setAccessToken(sessionData.access_token);
    console.log('Session generated:', sessionData);
  } catch (err) {
    console.error('Authentication failed:', err);
  }
}

async function getPortfolio() {
  try {
    const positions = await client.getNetPositions();
    const holdings = await client.getHoldings();
    const funds = await client.getFundSummary();
    
    console.log('Positions:', positions);
    console.log('Holdings:', holdings);
    console.log('Funds:', funds);
  } catch (err) {
    console.error('Error getting portfolio:', err);
  }
}

// Initialize the API calls
init();

Getting started with WebSocket client

import { MTicker } from 'mconnecttypea';

const apiKey = "your_api_key";
const accessToken = "generated_access_token";

const ticker = new MTicker({
  api_key: apiKey,
  access_token: accessToken
});

ticker.connect();

// Set up event handlers
ticker.onBroadcastReceived = onTicks;
ticker.onConnect = subscribe;
ticker.onClose = onDisconnect;
ticker.onError = onError;
ticker.onOrderTradeReceived = onOrderUpdate;

function onTicks(tick: any): void {
  console.log('Market data:', {
    token: tick.InstrumentToken,
    price: tick.LastPrice,
    mode: tick.Mode
  });
}

function subscribe(): void {
  ticker.sendLoginAfterConnect();
  const tokens = [5633, 2885]; // Instrument tokens
  ticker.subscribe(tokens);
  ticker.setMode('full', tokens);
}

function onDisconnect(): void {
  console.log('WebSocket disconnected');
}

function onError(error: any): void {
  console.log('WebSocket error:', error);
}

function onOrderUpdate(order: any): void {
  console.log('Order update:', order);
}

Order Management

// Place an order
const orderParams = {
  exchange: "NSE",
  tradingsymbol: "RELIANCE",
  transaction_type: "BUY",
  quantity: 1,
  product: "CNC",
  order_type: "LIMIT",
  price: 2500,
  validity: "DAY",
  variety: "regular"
};

const orderResponse = await client.placeOrder(orderParams);
console.log('Order placed:', orderResponse);

// Modify an order
const modifyParams = {
  order_id: "ORDER123",
  variety: "regular",
  quantity: 2,
  price: 2600,
  order_type: "LIMIT"
};

const modifyResponse = await client.modifyOrder(modifyParams);
console.log('Order modified:', modifyResponse);

// Cancel an order
const cancelResponse = await client.cancelOrder("ORDER123");
console.log('Order cancelled:', cancelResponse);

// Get order book
const orderBook = await client.getOrderBook();
console.log('Order book:', orderBook);

API Reference

Authentication

Method	Description
login()	Login with username/password
generateSession()	Generate session with OTP
verifyTOTP()	Verify TOTP
logout()	Logout

Orders

Method	Description
placeOrder()	Place new order
modifyOrder()	Modify existing order
cancelOrder()	Cancel order
getOrderBook()	Get order book
orderMargin()	Calculate order margin

Portfolio

Method	Description
getFundSummary()	Get fund summary
getNetPositions()	Get positions
getHoldings()	Get holdings
convertPosition()	Convert position

Market Data

Method	Description
getInstruments()	Get instruments master
getOHLC()	Get OHLC data
getLTP()	Get last traded price
getHistoricalCandleData()	Historical data
loserGainer()	Top gainers/losers

WebSocket Streaming

The SDK includes real-time WebSocket streaming capabilities for live market data and order updates.

WebSocket Features

• Real-time market data streaming
• Live order and trade updates
• Multiple subscription modes (LTP, Quote, Full)
• Automatic reconnection handling
• Event-driven architecture

WebSocket Dependencies

• ws: WebSocket client library
• @types/ws: TypeScript definitions for WebSocket

Running WebSocket Tests

# Run WebSocket streaming tests
npm run websocket

# Run REST API tests
npm run test

WebSocket Usage Example

import { MTicker } from 'mconnecttypea';

const ticker = new MTicker({
  api_key: "your_api_key",
  access_token: "your_access_token"
});

// Connect to WebSocket
ticker.connect();

// Event handlers
ticker.onConnect = () => {
  console.log('WebSocket connected');
  ticker.sendLoginAfterConnect();
  
  // Subscribe to instruments
  const tokens = [2885, 5633]; // RELIANCE, HDFCBANK
  ticker.subscribe(tokens);
  ticker.setMode('full', tokens);
};

ticker.onBroadcastReceived = (tick) => {
  console.log('Market data:', {
    token: tick.InstrumentToken,
    ltp: tick.LastPrice,
    volume: tick.Volume
  });
};

ticker.onOrderTradeReceived = (order) => {
  console.log('Order update:', order);
};

ticker.onError = (error) => {
  console.error('WebSocket error:', error);
};

ticker.onClose = () => {
  console.log('WebSocket disconnected');
};

A typical web application

In a typical web application where a new instance of views, controllers etc. are created per incoming HTTP request, you will need to initialise a new instance of MConnect client per request as well. This is because each individual instance represents a single user that's authenticated.

Hence, in your web application, typically:

• You will initialise an instance of the MConnect client
• Use the login() method to trigger OTP
• At the OTP verification step, obtain the OTP from user input
• Use generateSession() to obtain the access_token along with authenticated user data
• Store this response in a session and use the stored access_token to initialise instances of MConnect client for subsequent API calls.

Examples

Check the test files for detailed examples:

• REST API Usage
• WebSocket Streaming

Requirements

• Node.js v18.0.0 or higher
• TypeScript 4.0+ (optional)
• MConnect TypeA trading account
• API credentials from MConnect

License

MIT License - see LICENSE file for details.

MConnect Technology (c) 2025. Licensed under the MIT License.