# 🇬🇧 LSE UK Stock Screener — FTSE 100 Quotes (`nexgendata/lse-uk-stock-screener`) Actor

London Stock Exchange (LSE) UK stock screener API — FTSE 100 / 250 live quotes, market cap (GBP), P/E, P/B, dividend yield, ROE, sector. AstraZeneca, Shell, HSBC, Unilever, BP universe. Bloomberg Terminal / FactSet / Refinitiv Eikon alternative for hedge funds & quants. Pay-per-result.

- **URL**: https://apify.com/nexgendata/lse-uk-stock-screener.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $250.00 / 1,000 lse stock records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LSE UK Stock Screener — FTSE 100 Quotes & Fundamentals

Bloomberg Terminal alternative for the **London Stock Exchange**. Pull every FTSE 100, FTSE 250, or LSE main-market UK company in one structured dataset: price, percent change, market cap (GBP), revenue, P/E ratio, EPS, dividend yield, sector, industry, 52-week range, beta, RSI, and more — at a fraction of the cost of a Bloomberg, FactSet, or LSEG Workspace seat.

### 📊 Sample Output

[![🇬🇧 LSE UK Stock Screener — FTSE 100 Quotes sample output — 🇬🇧 LSE UK Stock Screener — FTSE 100 Quotes, premium API, JSON output, NexGenData premium dataset for analysts, hedge funds, compliance, and r](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/lse-uk-stock-screener-output.png)](https://apify.com/nexgendata/lse-uk-stock-screener)

Built for **hedge funds, quant researchers, ETF builders, equity-research analysts, fintech apps, and individual UK investors** who need clean, structured, programmatic access to London-listed equities without paying $24,000/year for a terminal license.

---

### What you get per stock

Every record returned is a complete UK-equity snapshot pulled in real time from a server-rendered listing source. Listing pass (always included):

- `symbol` — LSE ticker (e.g. `HSBA`, `AZN`, `SHEL`, `BP`, `ULVR`, `LSEG`, `BARC`)
- `name` — full legal name (e.g. "HSBC Holdings plc")
- `ticker_yahoo` — Yahoo Finance ticker with `.L` suffix (e.g. `HSBA.L`) for cross-referencing
- `price_gbx` — last traded price in pence (the native LSE quotation unit)
- `price_gbp` — same price converted to pounds (decimal)
- `pct_change` — intraday % change
- `market_cap_gbp` — absolute market capitalization in pounds
- `market_cap_billion_gbp` — same value in £B for easy reading
- `revenue_ttm_gbp` — trailing-12-month revenue
- `is_ftse100` — boolean, true for FTSE 100 constituents
- `is_ftse250` — boolean, true for FTSE 250 constituents
- `is_native_uk` — boolean, distinguishes native UK listings from International Order Book (IOB) ADRs
- `stockanalysis_url`, `yahoo_finance_url` — direct deep-links
- `scraped_at`, `exchange`, `country`, `currency`, `price_currency` — provenance and units

Fundamentals pass (when `enrich_fundamentals=true` — one extra HTTP request per stock):

- `pe_ratio`, `forward_pe`, `pb_ratio`, `eps_gbp`
- `net_income_gbp`, `shares_outstanding`
- `dividend_gbp`, `dividend_yield_pct`, `ex_dividend_date`
- `volume`, `avg_volume`, `previous_close_gbx`, `open_gbx`
- `week52_low_gbx`, `week52_high_gbx`, `day_low_gbx`, `day_high_gbx`
- `beta`, `rsi`, `earnings_date`
- `sector`, `industry` (required for sector keyword filtering)

---

### Inputs

| Input | Type | Default | What it does |
|---|---|---|---|
| `index` | enum | `FTSE100` | Market scope: `FTSE100`, `FTSE250`, or `LSE-all`. |
| `limit` | integer | `50` | Max stocks to return (in descending market-cap order). 1–2000. |
| `min_market_cap_gbp_billion` | integer | `0` | Floor on market cap in billions of GBP. `0` = no filter. |
| `sector` | string | `""` | Case-insensitive substring filter on sector / industry / company name. Requires `enrich_fundamentals=true` for sector matches. |
| `enrich_fundamentals` | boolean | `false` | Hit each stock's detail page to extract P/E, EPS, dividend yield, sector, etc. Roughly doubles runtime. |
| `proxyConfiguration` | object | `{useApifyProxy: true}` | Standard Apify proxy block. Default datacenter proxy is fine for stockanalysis.com. |

#### Recipe examples

**FTSE 100 daily snapshot (lightweight):**
```json
{ "index": "FTSE100", "limit": 100 }
````

Returns ~100 FTSE 100 names with price, market cap, % change — no enrichment overhead. Perfect for a daily portfolio dashboard or a market-open digest.

**UK banks deep dive:**

```json
{ "index": "FTSE100", "limit": 50, "sector": "bank", "enrich_fundamentals": true }
```

Returns HSBC, Barclays, Lloyds, NatWest, Standard Chartered with full fundamentals so you can compare P/E, P/B, dividend yields side-by-side.

**FTSE 250 mid-cap sweep:**

```json
{ "index": "FTSE250", "limit": 250 }
```

**Mega-caps only (£50B+):**

```json
{ "index": "LSE-all", "min_market_cap_gbp_billion": 50, "limit": 20 }
```

**UK pharma:**

```json
{ "index": "FTSE100", "sector": "pharma", "enrich_fundamentals": true }
```

**Oil & gas majors:**

```json
{ "index": "FTSE100", "sector": "oil", "enrich_fundamentals": true }
```

***

### How it works

The actor scrapes [stockanalysis.com/list/london-stock-exchange/](https://stockanalysis.com/list/london-stock-exchange/), a clean server-rendered universe page that aggregates every LSE-listed name sorted by market cap. We paginate through pages of 500 stocks, filter out International Order Book ADRs (codes like `0R1I`, `0HD6` — these are foreign companies cross-listed via depositary receipts and aren't true UK companies), and apply the requested index/cap/sector filters in memory.

When `enrich_fundamentals=true`, we additionally hit each stock's `/quote/lon/{symbol}/` detail page, parse the structured statistics tables, and add P/E, EPS, dividend, 52-week range, beta, sector, and industry to each record. Enrichment runs at concurrency 5 to be a polite scraper. Typical runtime: 10 stocks ≈ 8 seconds without enrichment, ~20 seconds with.

**Native UK ticker detection** — The upstream listing mixes native UK companies (2–5 alpha-char tickers like `HSBA`, `AZN`, `BP`) with IOB ADRs (4-char numeric-prefix tickers like `0R1I` for NVIDIA, `0HD6` for Alphabet). We keep only native UK main-market names by default so you get actual British companies, not US tech ADRs that happen to also trade in London.

**FTSE 100 membership** — The actor ships with the FTSE 100 constituent list embedded for instant `is_ftse100` flagging and `index=FTSE100` filtering. No external dependency.

**Currency notation** — Native LSE prices are quoted in **GBX (pence)**, not pounds. A "share price of 1,319.80" for HSBC means 1,319.80 pence = £13.20. We expose both `price_gbx` (the native unit) and `price_gbp` (decimal pounds for convenience), so you can use whichever your system expects.

***

### Pricing — Pay Per Event

This actor uses Apify's Pay-Per-Event pricing — you only pay for what you actually pull, no monthly fees, no commitments, no annual contracts. Compare that to Bloomberg Terminal at ~$2,000/month per seat or LSEG Workspace at ~$1,800/month: even pulling the full FTSE 350 daily, you'd recover the cost in under a week of analyst time saved.

| Event | Price | When charged |
|---|---|---|
| Actor start | $0.01 | Once when the run begins |
| LSE stock record | $0.25 | Per UK-listed stock record returned with price, market cap, P/E, P/B, dividend yield, sector, fundamentals |

**Worked examples (USD):**

- 10-stock smoke test: $0.01 + 10 × $0.25 = **$2.51**
- Full FTSE 100 sweep (100 names): $0.01 + 100 × $0.25 = **$25.01**
- FTSE 350 with fundamentals (350 names): $0.01 + 350 × $0.25 = **$87.51**
- Full LSE main market (~500 native UK names): $0.01 + 500 × $0.25 = **$125.01**

For comparison, a single Bloomberg Terminal seat is ~$24,000/year. This actor delivers the equivalent UK equity coverage at well under 1% of that, with no contract and no minimum.

***

### Use cases

- **Hedge fund alt-data** — refresh UK equity universes hourly, intraday, or daily; drop directly into your DuckDB / Snowflake / BigQuery warehouse.
- **Quant signal research** — backtest FTSE 100 / FTSE 250 signals (momentum, value, dividend, quality) on consistent point-in-time snapshots.
- **ETF construction** — build a custom FTSE-tilt ETF basket weighted by your own factor model.
- **Equity research desks** — feed a sector dashboard (UK banks, UK oil majors, UK pharma) without paying for a market-data terminal.
- **Fintech apps** — power a UK stock-screener feature inside a robo-advisor, brokerage app, or investing newsletter.
- **Compliance & treasury** — verify holdings, monitor index inclusion changes, track corporate actions on LSE constituents.
- **News / media** — generate "FTSE winners and losers" tables programmatically every market close.

***

### Output schema (sample record)

```json
{
  "symbol": "HSBA",
  "name": "HSBC Holdings plc",
  "ticker_yahoo": "HSBA.L",
  "price_gbx": 1319.8,
  "price_gbp": 13.198,
  "pct_change": -0.17,
  "market_cap_gbp": 226320000000,
  "market_cap_billion_gbp": 226.32,
  "market_cap_display": "226.32B",
  "revenue_ttm_gbp": 48300000000,
  "revenue_ttm_billion_gbp": 48.3,
  "is_ftse100": true,
  "is_ftse250": false,
  "is_native_uk": true,
  "stockanalysis_url": "https://stockanalysis.com/quote/lon/HSBA/",
  "yahoo_finance_url": "https://finance.yahoo.com/quote/HSBA.L",
  "pe_ratio": 14.43,
  "forward_pe": 10.51,
  "eps_gbp": 0.91,
  "dividend_yield_pct": 4.17,
  "ex_dividend_date": "May 14, 2026",
  "beta": 0.57,
  "rsi": 51.05,
  "week52_low_gbx": 835.30,
  "week52_high_gbx": 1410.60,
  "sector": "Financial Services",
  "industry": "Banks Diversified",
  "exchange": "LSE",
  "country": "United Kingdom",
  "currency": "GBP",
  "price_currency": "GBX",
  "scraped_at": "2026-05-10T12:00:00Z"
}
```

### FAQ

**Why pence, not pounds?** Because that's how the London Stock Exchange officially quotes UK equities. A 1,319.80 pence quote for HSBA = £13.20 per share. We expose both fields so you can use whichever matches your downstream system.

**What about ADRs and dual-listings?** By default we filter out International Order Book (IOB) ADRs to keep the universe clean for "UK companies only" use cases. If you want them too, set `index=LSE-all` and we'll keep both native and IOB tickers (those will show `is_native_uk=false`).

**FTSE 100 changes — how fresh is your constituent list?** The embedded list is updated periodically. Index membership reshuffles happen quarterly. If you need rigorous index-membership audit trails for compliance, cross-check against the official FTSE Russell quarterly index review.

**Rate limits / blocking?** We use Apify's datacenter proxy by default. Stockanalysis.com is generally cooperative. If you hit any limit, switch to RESIDENTIAL group in proxy config.

**Can I run this on a schedule?** Yes — every Apify actor supports cron scheduling. Run it at 5:00 PM London time daily for a market-close snapshot.

***

### Affiliate signup

Building a fleet of regional stock screeners across LSE, TSE, KOSPI, HKEX, TWSE, Eastmoney, NSE, B3 and more? Sign up to Apify through this affiliate link to support our work: **[apify.com/nexgendata?fpr=2ayu9b](https://apify.com/nexgendata?fpr=2ayu9b)**

***

*Built by NexGenData. Questions, bugs, or feature requests — reach out via the Apify Store contact form.*

***

### Explore the NexGenData Equity Data Suite

This actor is part of NexGenData's global equity data fleet. Whether you cover a single region or a multi-asset macro book, we have a screener for every major market:

#### Regional sisters

- 🔗 **[Xetra Germany Stock Screener](https://apify.com/nexgendata/xetra-germany-stock-screener)** — Deutsche Börse Xetra (DAX 40 / MDAX) fundamentals, market cap (EUR), P/E, dividend yield, sector — German equity data.
- 🔗 **[TSE Japan Stock Screener](https://apify.com/nexgendata/tse-japan-stock-screener)** — Tokyo Stock Exchange (Nikkei 225 / TOPIX) fundamentals, market cap (JPY), P/E, P/B, dividend yield, sector.
- 🔗 **[Finviz Stock Screener (US)](https://apify.com/nexgendata/finviz-stock-screener)** — US equities (NYSE / NASDAQ / AMEX) with 70+ filters — market cap, P/E, sector, technicals, insider activity.

#### Cross-region peers

- 🔗 **[ASX Australia Stock Screener](https://apify.com/nexgendata/asx-australia-stock-screener)** — ASX 200 / All Ordinaries fundamentals, market cap (AUD), P/E, dividend yield, sector — Australian equity data.
- 🔗 **[TSX Canada Stock Screener](https://apify.com/nexgendata/tsx-canada-stock-screener)** — Toronto Stock Exchange (TSX 60 / Composite) fundamentals, market cap (CAD), P/E, dividend yield, sector.

#### Multi-asset / specialty

- 🔗 **[Finance MCP Server](https://apify.com/nexgendata/finance-mcp-server)** — Unified Model Context Protocol server exposing the full NexGenData equity fleet to Claude, Cursor & MCP-aware LLMs.

#### Browse the full NexGenData catalog

**[→ See all 220+ NexGenData actors at apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b)** — equity screeners across 25+ markets, lead generation, SEC filings, B2B intelligence, MCP servers, and more.

***

### Why NexGenData vs. paid alternatives

| Tool | Annual cost | API access | Coverage |
|------|-------------|------------|----------|
| Bloomberg Terminal | ~$24,000/seat | Limited | Global |
| FactSet | ~$15,000/seat | Paid add-on | Global |
| Refinitiv Eikon | ~$22,000/seat | Paid add-on | Global |
| S\&P Capital IQ | ~$20,000/seat | Paid add-on | Global |
| **NexGenData UK Screener** | **Pay-per-result** | **Native** | **UK**          |

Run this actor once per day for a typical institutional-scale workflow (~200 records/day) and your annual cost is approximately **$1,800–2,000** — a 90-95% discount vs. the major paid alternatives, with no seat licensing, no minimum commitment, and full programmatic access.

# Actor input Schema

## `index` (type: `string`):

Which UK market scope to screen: FTSE100 (FTSE 100 blue-chip constituents only, e.g. HSBC HSBA, AstraZeneca AZN, Shell SHEL, BP, Unilever ULVR), FTSE250 (FTSE 250 mid-cap constituents), or LSE-all (entire London Stock Exchange native main-market UK listings — excludes International Order Book ADRs).

## `limit` (type: `integer`):

Maximum number of UK stocks to return. Stocks are returned in descending market-cap order. Use 10 for a quick smoke test, 100 for the full FTSE 100, 250 for FTSE 250, 350+ for combined FTSE 350 coverage.

## `min_market_cap_gbp_billion` (type: `integer`):

Filter to stocks with market cap above this threshold, in BILLIONS of GBP. Examples: 10 = £10B (roughly large-cap, FTSE 100 floor is around £4-5B), 50 = £50B (mega-cap like HSBC, AstraZeneca, Shell), 100 = £100B (top 5 UK companies). Leave at 0 for no filter.

## `sector` (type: `string`):

Optional case-insensitive substring filter applied to sector, industry, and company name. Examples: 'bank' (HSBC, Barclays, Lloyds, NatWest), 'oil' (Shell, BP), 'pharma' (AstraZeneca, GSK), 'mining' (Rio Tinto, Anglo American, Glencore), 'tobacco' (BAT, Imperial Brands). Leave blank for no filter. Note: sector matching requires enrich\_fundamentals=true.

## `enrich_fundamentals` (type: `boolean`):

If true, fetch each stock's detail page on stockanalysis.com to extract P/E ratio, EPS, dividend yield, shares outstanding, beta, RSI, 52-week range, sector and industry classification. Adds ~1 HTTP request per stock and roughly doubles runtime. Required if you want to filter by sector.

## `proxyConfiguration` (type: `object`):

Apify proxy configuration. Defaults to Apify datacenter proxy for reliable access to stockanalysis.com. Use RESIDENTIAL group if you hit rate limits.

## Actor input object example

```json
{
  "index": "FTSE100",
  "limit": 50,
  "min_market_cap_gbp_billion": 0,
  "enrich_fundamentals": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "index": "FTSE100",
    "limit": 50,
    "min_market_cap_gbp_billion": 0,
    "sector": "",
    "enrich_fundamentals": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/lse-uk-stock-screener").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "index": "FTSE100",
    "limit": 50,
    "min_market_cap_gbp_billion": 0,
    "sector": "",
    "enrich_fundamentals": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/lse-uk-stock-screener").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "index": "FTSE100",
  "limit": 50,
  "min_market_cap_gbp_billion": 0,
  "sector": "",
  "enrich_fundamentals": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nexgendata/lse-uk-stock-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/lse-uk-stock-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🇬🇧 LSE UK Stock Screener — FTSE 100 Quotes",
        "description": "London Stock Exchange (LSE) UK stock screener API — FTSE 100 / 250 live quotes, market cap (GBP), P/E, P/B, dividend yield, ROE, sector. AstraZeneca, Shell, HSBC, Unilever, BP universe. Bloomberg Terminal / FactSet / Refinitiv Eikon alternative for hedge funds & quants. Pay-per-result.",
        "version": "0.0",
        "x-build-id": "dZA5HnV4xb8SGjJL2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~lse-uk-stock-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-lse-uk-stock-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~lse-uk-stock-screener/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-lse-uk-stock-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~lse-uk-stock-screener/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-lse-uk-stock-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "index": {
                        "title": "Index / Market",
                        "enum": [
                            "FTSE100",
                            "FTSE250",
                            "LSE-all"
                        ],
                        "type": "string",
                        "description": "Which UK market scope to screen: FTSE100 (FTSE 100 blue-chip constituents only, e.g. HSBC HSBA, AstraZeneca AZN, Shell SHEL, BP, Unilever ULVR), FTSE250 (FTSE 250 mid-cap constituents), or LSE-all (entire London Stock Exchange native main-market UK listings — excludes International Order Book ADRs).",
                        "default": "FTSE100"
                    },
                    "limit": {
                        "title": "Limit (stocks returned)",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of UK stocks to return. Stocks are returned in descending market-cap order. Use 10 for a quick smoke test, 100 for the full FTSE 100, 250 for FTSE 250, 350+ for combined FTSE 350 coverage.",
                        "default": 50
                    },
                    "min_market_cap_gbp_billion": {
                        "title": "Min market cap (billion GBP)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Filter to stocks with market cap above this threshold, in BILLIONS of GBP. Examples: 10 = £10B (roughly large-cap, FTSE 100 floor is around £4-5B), 50 = £50B (mega-cap like HSBC, AstraZeneca, Shell), 100 = £100B (top 5 UK companies). Leave at 0 for no filter.",
                        "default": 0
                    },
                    "sector": {
                        "title": "Sector / industry / name keyword",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter applied to sector, industry, and company name. Examples: 'bank' (HSBC, Barclays, Lloyds, NatWest), 'oil' (Shell, BP), 'pharma' (AstraZeneca, GSK), 'mining' (Rio Tinto, Anglo American, Glencore), 'tobacco' (BAT, Imperial Brands). Leave blank for no filter. Note: sector matching requires enrich_fundamentals=true."
                    },
                    "enrich_fundamentals": {
                        "title": "Enrich with fundamentals (slower)",
                        "type": "boolean",
                        "description": "If true, fetch each stock's detail page on stockanalysis.com to extract P/E ratio, EPS, dividend yield, shares outstanding, beta, RSI, 52-week range, sector and industry classification. Adds ~1 HTTP request per stock and roughly doubles runtime. Required if you want to filter by sector.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Defaults to Apify datacenter proxy for reliable access to stockanalysis.com. Use RESIDENTIAL group if you hit rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```