Building Mutual Fund Apps Using NSE NMF II or BSE StAR MF APIs: A Developer’s Guide

Introduction: The Rise of Digital Mutual Fund Platforms

Imagine a world where investors can:

Open an account in minutes
Buy mutual funds with one click
Track their portfolio in real time
Start SIPs instantly

This isn’t science fiction. It’s happening now—thanks to APIs from India’s top stock exchanges.

The National Stock Exchange (NSE) and the Bombay Stock Exchange (BSE) have launched powerful Application Programming Interfaces (APIs) that allow developers to build custom mutual fund applications.

Whether you’re a fintech startup, a wealth management platform, or an independent financial advisor, these APIs open the door to automated, scalable, and secure mutual fund distribution.

But here’s the catch:
👉 Most developers don’t know how to use them.

In this guide, we’ll walk you through everything you need to know to:

Build a mutual fund app using NSE NMF II API
Use BSE StAR MF API
Integrate key features like client onboarding, transactions, and portfolio tracking
Avoid common pitfalls

By the end, you’ll have the knowledge to create a professional-grade mutual fund app—from scratch.

Let’s get started.

What Are NSE NMF II and BSE StAR MF APIs?

🔧 What Is an API?

An API (Application Programming Interface) is a set of rules that allows software applications to communicate with each other.

For example:
Your mobile app sends a request → The NSE API processes it → Returns data (e.g., available schemes) → Your app displays it.

📡 Why Are These APIs Important?

They enable:

Real-time transaction execution
Automated client onboarding
Instant portfolio updates
SIP registration and redemption

Without them, every action would require manual login and clicking—slow, error-prone, and impossible to scale.

💡 Key Fact: The NSE NMF II and BSE StAR MF platforms are built for distributors, not individual investors. So, you must be an authorized MFD to access these APIs.

Who Can Use These APIs?

Only registered Mutual Fund Distributors (MFDs) can access the APIs.

To qualify:

Have a valid ARN (Association of Mutual Funds in India Registration Number)
Be empanelled on either NSE NMF II or BSE StAR MF
Apply for API access via the official portal

✅ You cannot use these APIs as a regular investor.

How to Access the NSE NMF II API

The NSE NMF II API (now part of NSE MF Invest) is designed for developers who want to integrate mutual fund services into their apps.

Step 1: Register as an MFD on NSE

Before applying for API access, you must:

Pass the NISM-Series-V-A exam
Get your ARN certificate
Complete KYD (Know Your Distributor)
Apply for NSE membership

Once approved, you’ll receive your Super User Login ID and Password.

Step 2: Apply for API Access

Go to the official NSE website: https://nsenmf.com
Navigate to API Access or Developer Portal
Fill out the API Application Form
Submit required documents:

ARN Certificate
PAN Card
Bank Details
Company Registration (if applicable)

⏳ Processing Time: 7–10 working days

Step 3: Receive API Credentials

After approval, you’ll get:

API Key
Secret Key
Base URL (e.g., https://api.nsenmf.com/v1/)
Test Environment (for development)
Production Environment (for live use)

🔐 Security Tip: Never share your keys. Store them securely.

How to Access the BSE StAR MF API

BSE offers a similar API for its StAR MF platform.

Step 1: Register as an MFD on BSE

Follow the same process as NSE:

Get your ARN
Complete KYD
Apply for BSE membership

Step 2: Request API Access

Visit the BSE developer portal: https://www.bsestarmf.com
Click “Developer Access” or “API Portal”
Submit your application with:

ARN number
PAN
Business details

Step 3: Get Your API Keys

You’ll receive:

Client ID & Client Secret
Authentication Token
Endpoint URLs

🚀 Note: BSE may charge a small fee for API access (check current rates).

Core Features You Can Build with These APIs

Here are the most valuable features you can implement:

Feature	API Used	Description
Client Onboarding (UCC Registration)	NSE/BSE	Create a unique client code (UCC) with PAN, bank, and KYC verification
Lumpsum Investment	NSE/BSE	Place one-time purchases across all AMCs
Systematic Investment Plan (SIP)	NSE/BSE	Set up auto-debits with mandate activation
Redemption	NSE/BSE	Sell units and transfer funds to client’s bank
Switching	NSE/BSE	Move money between schemes within the same AMC
Portfolio Tracking	NSE/BSE	Fetch real-time holdings, NAV, and returns
Order Status Monitoring	NSE/BSE	Track pending, executed, or rejected orders
Transaction Reports	NSE/BSE	Generate statements and reports

Step-by-Step: Building a Mutual Fund App

Let’s walk through building a basic app using the NSE NMF II API.

Step 1: Set Up Your Development Environment

Choose a language: Python, Node.js, Java, etc.
Install tools: Postman, curl, or IDE
Create a project folder

Step 2: Authenticate with the API

All requests require authentication.

For NSE NMF II API:

Send a POST request to:
https://api.nsenmf.com/v1/auth/login
Body (JSON):

   {
     "client_id": "your_client_id",
     "client_secret": "your_client_secret"
   }

Get a Bearer Token in response

✅ Store the token securely. It expires after 1 hour.

Step 3: Create a Client Account (UCC)

Use the /clients endpoint.

Request:

POST /v1/clients
Authorization: Bearer <your_token>
Content-Type: application/json

{
  "pan": "ABCDE1234F",
  "mobile": "9876543210",
  "email": "client@example.com",
  "bank": {
    "account_number": "123456789012",
    "ifsc": "HDFC0000001"
  },
  "holding_nature": "Single"
}

Response:

{
  "ucc": "UCC123456789",
  "status": "Pending_Authorization"
}

📌 The client will receive an authorization link via SMS/email.

Step 4: Place a Lumpsum Order

Use the /orders endpoint.

Request:

POST /v1/orders
Authorization: Bearer <your_token>
Content-Type: application/json

{
  "ucc": "UCC123456789",
  "transaction_type": "purchase",
  "scheme_code": "SCH001",
  "amount": 50000,
  "folio": "FOLIO123"
}

Response:

{
  "order_id": "ORD123456",
  "status": "Pending_Client_Authorization"
}

💡 The client must approve via OTP before payment.

Step 5: Start an SIP

Requires two steps: Mandate + Registration.

Step 5a: Register Mandate

POST /v1/mandates
Authorization: Bearer <your_token>

{
  "ucc": "UCC123456789",
  "max_amount": 10000,
  "frequency": "monthly",
  "start_date": "2025-04-01"
}

Step 5b: Register SIP

POST /v1/xsip
Authorization: Bearer <your_token>

{
  "ucc": "UCC123456789",
  "umrn": "UMRN123456",
  "scheme_code": "SCH001",
  "amount": 5000,
  "frequency": "monthly",
  "start_date": "2025-04-01"
}

✅ Once both are approved, the SIP runs automatically.

Key Differences Between NSE NMF II and BSE StAR MF APIs

Feature	NSE NMF II API	BSE StAR MF API
Platform Name	NSE MF Invest	BSE StAR MF
API Documentation	Available on nsenmf.com	Available on bsestarmf.com
Rate Limiting	100 requests/min	80 requests/min
Support	Email & chat support	Email only
Ease of Use	Modern, REST-based	Slightly outdated
Integration Speed	Faster	Slower
Fees	Currently free	May charge ₹500/year

✅ Recommendation: Use NSE NMF II API for better performance and future-proofing.

Best Practices for API Integration

Avoid these common mistakes:

❌ Don’t Hardcode API Keys

Store credentials in environment variables or secure vaults.

❌ Don’t Ignore Error Handling

Always check for HTTP status codes:

200: Success
400: Bad Request (invalid data)
401: Unauthorized (expired token)
500: Server Error

❌ Don’t Skip Authentication

Every request must include the Bearer Token.

✅ Do Use Webhooks

Set up webhooks to receive real-time notifications (e.g., order status changes).

✅ Do Test in Sandbox First

Use the test environment before going live.

Common Challenges & How to Solve Them

1. Client Authorization Delays

Problem: Clients take hours to approve links.
Solution: Send reminders via email/SMS. Offer quick approval options (e.g., UPI link).

2. Bank Verification Failures

Problem: Penny drop fails due to name mismatch.
Solution: Ask clients to upload a cancelled cheque.

3. API Rate Limits Exceeded

Problem: Too many requests in a short time.
Solution: Implement rate limiting in your app.

4. Data Not Syncing

Problem: Portfolio shows old values.
Solution: Call the /portfolio endpoint hourly.

FAQs: Building Mutual Fund Apps with NSE/BSE APIs

1. Can I use these APIs without being an MFD?

No. Only registered distributors can access them.

2. Are there any fees for API usage?

NSE currently waives fees. BSE may charge a nominal fee.

3. How long does it take to get API access?

7–10 working days.

4. Can I build a mobile app with these APIs?

Yes. Use SDKs or call endpoints directly.

5. What programming languages work best?

Python, Node.js, and Java are widely supported.

6. Is there a free trial?

Yes. Both platforms offer sandbox environments.

7. Can I integrate multiple AMCs?

Yes. The API supports all 45+ AMCs on NSE/BSE.

8. How do I handle refunds?

Use the redemption API. Funds go back to the client’s bank.

Conclusion: Power Up Your Financial App

The future of mutual fund investing is digital, automated, and personalized.

With NSE NMF II and BSE StAR MF APIs, you can:

Build apps that save time
Offer instant onboarding
Enable real-time transactions
Scale your business globally

Whether you’re a developer, fintech founder, or financial advisor, these APIs give you the power to innovate.

👉 Want help building your mutual fund app? Let our experts handle the integration, compliance, and support. Get API Development Assistance Today.

Start today. The future of finance is in your hands.