London Stock Exchange APIlondonstockexchange.com ↗
Fetch FTSE 100 and FTSE 250 constituent data from the London Stock Exchange: stock codes, market cap, prices, change, and 52-week range.
What is the London Stock Exchange API?
The London Stock Exchange API exposes 1 endpoint — get_ftse100_constituents — that returns all constituents of a FTSE index in a single call, covering up to 250 stocks with 9 data fields per record including price, market cap, 52-week range, and percentage change. It handles pagination automatically so you receive the full constituent list without multiple round-trips.
curl -X GET 'https://api.parse.bot/scraper/ffe09952-73ef-4452-9dd8-79807eba28e5/get_ftse100_constituents?index_name=ftse-100' \ -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 londonstockexchange-com-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: LSE FTSE Index API — fetch constituents and inspect trading data."""
from parse_apis.london_stock_exchange_ftse_index_api import LSE, IndexName, NotFoundError
client = LSE()
# Fetch the FTSE 100 index by constructing from its slug.
ftse100 = client.index(name=IndexName.FTSE_100)
# List constituents with a cap — each has price, market cap, 52-week range.
for stock in ftse100.constituents.list(limit=5):
print(stock.code, stock.name, stock.currency, stock.mid_price, stock.market_cap)
# Drill into one constituent for 52-week range analysis.
top = ftse100.constituents.list(limit=1).first()
if top:
print(top.code, top.high_52w, top.low_52w, top.change_percent)
# Refresh the index to get updated totals.
try:
refreshed = ftse100.refresh()
print(refreshed.name, refreshed.total, refreshed.count)
except NotFoundError as exc:
print(f"Index not found: {exc}")
print("exercised: index construct / constituents.list / refresh / NotFoundError catch")
Get all constituents of a FTSE index with their current trading data including price, change, market cap, and 52-week range. Automatically paginates through all server-side pages to return every constituent in a single response. The index_name parameter selects which FTSE index to query; defaults to ftse-100.
| Param | Type | Description |
|---|---|---|
| index_name | string | FTSE index slug. Verified working values: 'ftse-100', 'ftse-250'. Other indices may exist but are not guaranteed to have data. |
{
"type": "object",
"fields": {
"count": "integer - number of constituent records returned",
"index": "string - the index slug queried",
"total": "integer - total number of constituents in the index",
"constituents": "array of Constituent objects with trading data"
},
"sample": {
"data": {
"count": 100,
"index": "ftse-100",
"total": 100,
"constituents": [
{
"code": "DCC",
"name": "DCC PLC",
"change": 265,
"52w_low": 4188,
"52w_high": 6265,
"currency": "GBX",
"mid_price": 5875,
"last_price": 5805,
"market_cap": 4732497079,
"change_sign": "+1",
"description": "DCC PLC ORD EUR0.25 (CDI)",
"change_percent": 4.7834
}
]
},
"status": "success"
}
}About the London Stock Exchange API
What the API Returns
The get_ftse100_constituents endpoint returns a constituent list for a given FTSE index. The response includes a top-level count (records returned), total (full index size), and index (the slug queried), plus a constituents array. Each constituent object carries code (LSE ticker), name, description, currency, market_cap, last_price, mid_price, change, and change_percent. This gives you a snapshot of current trading data for every member of the index in one response.
Index Coverage and the index_name Parameter
The index_name input accepts an index slug string. Two values are verified to return data: ftse-100 and ftse-250. Other slugs such as ftse-aim-uk-50 may be passed but data availability depends on what the London Stock Exchange publishes for that index. If a slug has no upstream data, the endpoint will return an empty or partial result rather than an error, so callers should check the count field.
Pagination and Response Shape
The endpoint paginates internally and aggregates all pages before returning, meaning count should equal total for supported indices. The market_cap field reflects the capitalisation figure as published on the LSE constituents table. Prices (last_price, mid_price) and change/change_percent reflect the values available at the time of the request and are suitable for intraday snapshots rather than tick-level streaming.
The London Stock Exchange API is a managed, monitored endpoint for londonstockexchange.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when londonstockexchange.com 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 londonstockexchange.com 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?+
- Screen all FTSE 100 stocks by market_cap to identify the largest-cap constituents for portfolio weighting.
- Track daily price change and change_percent across FTSE 250 members to flag unusual movers.
- Build a 52-week high/low dashboard using the range fields returned per constituent.
- Sync LSE ticker codes and company names into an internal instrument master for trade reconciliation.
- Monitor currency fields to identify non-GBP-denominated constituents listed on the LSE.
- Generate a mid-price vs. last-price spread report across the full FTSE 100 constituent list.
- Populate an index-tracker app with live constituent counts and per-stock trading data.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does the London Stock Exchange offer an official developer API?+
What does get_ftse100_constituents return for each stock?+
code (ticker), name, description, currency, market_cap, last_price, mid_price, change (absolute), change_percent, and 52-week range data. The top-level response also includes count, total, and the index slug that was queried.Which indices can I query, and are all FTSE indices supported?+
ftse-100 and ftse-250 slugs are verified to return full constituent lists. Other slugs like ftse-aim-uk-50 may return incomplete or no data depending on upstream availability. The API currently covers these two primary indices. You can fork it on Parse and revise it to add support for additional index slugs as they become available.