NSE APInse.comhttps: ↗
Access NSE India's current-day bulk deals, block deals, and short selling data via a single API endpoint. Returns symbol, client, quantity, and trade price.
What is the NSE API?
The NSE India Large Deals API exposes today's large deal activity from the National Stock Exchange of India through a single endpoint, get_large_deals, returning up to 6 fields per deal record. It covers three deal categories — bulk deals, block deals, and short selling positions — and returns the trading symbol, security name, client name, trade direction, quantity, and weighted average price for each transaction reported on the current trading day.
curl -X GET 'https://api.parse.bot/scraper/e447e0fe-0f2a-484e-b8d8-a9781930f7e7/get_large_deals?deal_type=bulk' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace nse-comhttps-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: NSE India Large Deals — browse bulk, block, and short deals."""
from parse_apis.nse_comhttps_api import NseDeals, DealType, InvalidDealType
client = NseDeals()
# Fetch the full snapshot to see the trading date and total count.
snapshot = client.deal_snapshots.fetch(deal_type=DealType.BULK)
print(f"Bulk deals as on {snapshot.as_on_date}: {snapshot.total_count} total")
# Iterate individual bulk deals with a total-items cap.
for deal in client.deals.list(deal_type=DealType.BULK, limit=5):
print(f"{deal.symbol} {deal.buy_sell} qty={deal.quantity_traded} price={deal.trade_price}")
# Drill into short selling data — take just the first record.
try:
short_deal = client.deals.list(deal_type=DealType.SHORT, limit=1).first()
except InvalidDealType:
short_deal = None
print("Short selling data not available today")
if short_deal is not None:
print(f"First short deal: {short_deal.symbol} — {short_deal.client_name}")
print("exercised: deal_snapshots.fetch / deals.list (bulk, short)")
Returns NSE India's current large-deals snapshot for the most recent trading day whose disclosures NSE has published. Every call is a fresh, cache-bypassing fetch from NSE's origin; nothing is cached by this API, so the payload is byte-for-byte what NSE's own Large Deals page and its bulk.csv/block.csv publications show at that moment. Data includes bulk deals, block deals, or short selling positions depending on the deal_type parameter. Each deal record includes the trading symbol, security name, client name, buy/sell direction, quantity traded, and weighted average trade price; quantity_traded and trade_price are returned as numeric strings exactly as NSE publishes them. Short selling data may have null values for client_name, buy_sell, trade_price, and remarks fields; block deals carry null remarks. as_on_date is the trading day the snapshot pertains to as stated by NSE. It legitimately lags the calendar date on weekends, on NSE trading holidays (published in NSE's trading holiday calendar), and on a trading day until NSE publishes that session's disclosures after market close (India time) — for example, after a Friday session followed by a Monday holiday the snapshot still reads the Friday date throughout Tuesday until Tuesday's disclosures appear. Returns all deals of the selected type in a single response with no pagination. An unrecognized deal_type is rejected with a 422 stale_input error.
| Param | Type | Description |
|---|---|---|
| deal_type | string | Type of large deal to retrieve. |
{
"type": "object",
"fields": {
"deals": "Array of deal records (date, symbol, security_name, client_name, buy_sell, quantity_traded, trade_price, remarks)",
"deal_type": "The deal type that was requested (bulk, block, or short)",
"as_on_date": "Trading day the snapshot pertains to as published by NSE, in DD-Mon-YYYY format; the latest day with published disclosures, which can precede the calendar date",
"total_count": "Total number of deals of this type as reported by NSE"
},
"sample": {
"data": {
"deals": [
{
"date": "13-Aug-2026",
"symbol": "ASIANTILES",
"remarks": "-",
"buy_sell": "BUY",
"client_name": "THAKKAR NILESHKUMAR FARSHURAM HUF",
"trade_price": "53.18",
"security_name": "Asian Granito India Limit",
"quantity_traded": "2322004"
}
],
"deal_type": "bulk",
"as_on_date": "13-Aug-2026",
"total_count": 112
},
"status": "success"
}
}About the NSE API
What the API Returns
The get_large_deals endpoint returns a structured response with four top-level fields: deals (the array of individual records), deal_type (confirming which category was requested), as_on_date (the trading date in DD-Mon-YYYY format), and total_count (the number of deals in the response). Each object in the deals array contains the trading symbol, security name, the client or entity involved, whether they bought or sold, the quantity traded, and the weighted average trade price.
Filtering by Deal Type
The deal_type parameter is optional. Accepted values are bulk, block, and short (for short selling). Bulk deals are transactions where the traded quantity exceeds 0.5% of a company's equity shares. Block deals are negotiated trades executed in a separate window. Short selling records capture disclosed short positions. If deal_type is omitted, the API returns the default category. The deal_type field in the response always confirms what was fetched.
Data Scope and Freshness
All data corresponds to the current trading day, as indicated by as_on_date. This is intraday and end-of-day large deal disclosure data from NSE's public market data feed. Historical deal records for prior sessions are not exposed through this endpoint. Coverage is limited to equity instruments listed on NSE India; derivatives, SME, or currency segment deals are not included.
The NSE API is a managed, monitored endpoint for nse.comhttps: — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when nse.comhttps: changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official nse.comhttps: API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitor which institutional clients are taking large bulk deal positions in specific NSE-listed stocks
- Alert on block deal activity for a watchlist of securities using the symbol field
- Aggregate short selling disclosures by client name to track directional bets on individual stocks
- Build an intraday dashboard showing total_count of bulk vs block deals as a market activity signal
- Cross-reference buy/sell direction with price movement for stocks appearing in large deal records
- Screen for stocks with unusually high traded quantity in bulk deals relative to their typical volume
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does NSE India have an official developer API?+
What does the deal_type parameter control, and what happens if I omit it?+
deal_type parameter filters results to one of three categories: bulk, block, or short. Each maps to a distinct disclosure type on NSE. The deal_type field in the response always reflects what was returned, so you can confirm the active filter. If the parameter is omitted, the endpoint returns the default deal category.Does the API return historical large deal data from prior trading sessions?+
as_on_date. Historical records from prior sessions are not currently exposed. You can fork this API on Parse and revise it to add an endpoint that accepts a date parameter and returns historical large deal records.Are large deals from the SME platform or derivatives segment included?+
How current is the data within a trading day?+
as_on_date field confirms the date the data pertains to, but the API does not expose an intraday timestamp at the individual deal level.