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

``bash
npm install mconnecttypea
`

Getting started with API

`typescript
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

`typescript
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

`typescript
// 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

$3


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

$3

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

$3

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

$3

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

$3

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

$3

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

$3

`bash


Run WebSocket streaming tests

npm run websocket

Run REST API tests

npm run test
`

$3

`typescript
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.