# FT Markets Scraper (`publicmoney/ft-markets-scraper`) Actor

Extract Financial Times tearsheets for listings worldwide: price, day and 52-week range, bid and offer, average volume, shares outstanding, free float, market cap, PE and EPS, in local currency. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/ft-markets-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

US-focused sources stop at US listings, and a London, Frankfurt or Tokyo ticker returns nothing. The Financial Times tearsheet covers exchanges worldwide, and this Actor reads it: price, day range, bid and offer, average volume, shares outstanding and free float, PE and EPS, for any instrument the FT lists, addressed in its own `SYMBOL:EXCHANGE` form.

### What it does

- Covers **listings worldwide**, not just the US, which is the reason to reach for this over the other equity Actors in this fleet.
- Returns **one record per instrument**, in order. An instrument the FT does not list comes back with `status: "failed"` and a reason.
- Carries **free float alongside shares outstanding**, so you can see how much of a company actually trades.
- Reports **bid and offer** next to the last price, which many tearsheet sources omit.
- Gives the key figures **twice**: as the FT prints them and as numbers you can sort on (`marketCapNumeric`, `pETtmNumeric`).
- Takes instruments in the **FT's own `SYMBOL:EXCHANGE` form**, so a cross-listed ticker is unambiguous.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Price a non-US listing | Pass `SHEL:LSE` or `7203:TYO` and read `value` with its own currency |
| Cover a global portfolio in one run | Mix US, European and Asian instruments in the same list |
| See how much of a company trades | Compare `freeFloat` against `sharesOutstanding` |
| Watch the spread on a thin listing | Subtract `bid` from `offer` |
| Compare valuation across venues | Read `pETtmNumeric` for the same company on two listings |
| Feed a finance agent | Call the Actor over MCP and let the model ask for the symbol it needs |

### Quick start

1. Click **Try for free**.
2. Add your instruments, one per line, in the FT's `SYMBOL:EXCHANGE` form: `AAPL:NSQ`, `SHEL:LSE`, `BMW:GER`. The exchange code is the FT's own, so `NSQ` is Nasdaq.
3. Find an instrument's exact code by searching it on the FT markets site and reading it off the tearsheet URL.
4. Click **Start**. Rows appear within seconds.
5. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `instruments` | array | `AAPL:NSQ` | Instruments to read, in the FT's `SYMBOL:EXCHANGE` form |
| `maxItems` | integer | `0` | Caps how many instruments are read. `0` reads them all |

```json
{
    "instruments": [
        "AAPL:NSQ",
        "SHEL:LSE",
        "BMW:GER"
    ],
    "maxItems": 0
}
```

### Output

One dataset item per instrument. Fields the FT does not publish for an instrument are dropped rather than returned as `null`, and each record carries its own currency because a global list mixes them.

| Field group | Fields |
| --- | --- |
| Identity | `status`, `tickerSymbol`, `name`, `exchange`, `currency`, `url` |
| Price | `value`, `change`, `changePercent`, `open`, `previousClose`, `bid`, `offer` |
| Ranges and volume | `dayLow`, `dayHigh`, `fiftyTwoWeekLow`, `fiftyTwoWeekHigh`, `avgVolume` |
| Share structure | `sharesOutstanding`, `freeFloat`, `marketCap`, `marketCapNumeric` |
| Valuation | `pETtm`, `pETtmNumeric`, `epsTtm`, `dividendYieldPercent` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "tickerSymbol": "SHEL:LSE",
    "name": "Shell PLC",
    "exchange": "London Stock Exchange",
    "currency": "GBX",
    "value": 2884.5,
    "change": -18.0,
    "changePercent": -0.62,
    "open": 2901.0,
    "previousClose": 2902.5,
    "bid": 2884.0,
    "offer": 2885.0,
    "dayLow": 2871.5,
    "dayHigh": 2906.0,
    "avgVolume": 8412006,
    "sharesOutstanding": 5884000000,
    "freeFloat": 5871200000,
    "marketCap": "169.72bn",
    "marketCapNumeric": 169720000000,
    "pETtm": "12.44",
    "pETtmNumeric": 12.44,
    "validFrom": "2026-09-04T16:35:00.000Z",
    "url": "https://markets.ft.com/data/equities/tearsheet/summary?s=SHEL:LSE"
}
```

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~ft-markets-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"instruments": ["AAPL:NSQ", "SHEL:LSE", "BMW:GER"], "maxItems": 0}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/ft-markets-scraper").call(run_input={"instruments": ["AAPL:NSQ", "SHEL:LSE", "BMW:GER"], "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["name"], item["value"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/ft-markets-scraper"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Record with data | $0.002 | $0.0007 |
| Actor start | $0.00005 per GB | Same |

A record that returned no data is published as a failure row and is **never charged**. Six volume tiers apply, so the per-record price falls with monthly volume.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| An instrument returns `failed` | The exchange code is wrong. The FT uses its own codes, so Nasdaq is `NSQ` and not `NASDAQ`. Search the instrument on the FT site and copy the code from the tearsheet URL. |
| The price looks a hundred times too large | Check `currency`. London listings are quoted in pence (`GBX`), not pounds, so 2884.5 is 28.845 pounds. |
| `freeFloat` equals `sharesOutstanding` | The whole share count is freely traded, which is normal for a widely held company. |
| `pETtm` is missing | The FT publishes no trailing PE for loss-making companies and for instruments that are not equities. |
| A US ticker works but has fewer fields than elsewhere | The FT tearsheet is thinner on US listings than a US-native source. For US tickers the StockAnalysis or Finviz Actor returns more. |

### FAQ

#### Does the Financial Times have a markets API?

No. The FT publishes no documented public API for this data. The endpoints that libraries reach for are internal and unsupported, and they change without notice. This Actor reads the public markets tearsheet, which is why it keeps working.

#### Why use this instead of the other equity Actors?

International coverage. The Yahoo, Nasdaq, CNBC, Finviz and StockAnalysis Actors are strongest on US listings, while the FT tearsheet covers exchanges worldwide, so a London, Frankfurt or Tokyo listing works here.

#### What is the SYMBOL:EXCHANGE format?

The FT's own instrument id, made of the ticker and its exchange code: `AAPL:NSQ`, `SHEL:LSE`, `BMW:GER`. The codes are the FT's, not the exchange's own, so copy them from a tearsheet URL.

#### Why is a London price in the thousands?

London equities are quoted in pence, and the `currency` field says `GBX` rather than `GBP`. Divide by 100 for pounds.

#### Does it return historical prices?

No. Each record is the current snapshot as the source publishes it. To build a series, schedule the Actor and let the dataset accumulate a row per input per run. Each row carries `validFrom`, so the series is correctly timestamped.

#### Do I need a FT Markets API key?

No. You need an Apify token to call the Actor over the API. No FT Markets credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

#### Is it legal to scrape FT Markets?

This Actor reads public FT Markets data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

### Changelog

- **0.0.2** Added free float, bid and offer, and the numeric twins for cap and PE.
- **0.0.1** First release. The FT tearsheet for any listed instrument.

### Feedback

Found a field FT Markets publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

## `instruments` (type: `array`):

Instruments to read, one per line, in the FT's own SYMBOL:EXCHANGE form. The exchange codes are the FT's rather than the exchange's own, so Nasdaq is NSQ; find an instrument's exact code by searching it on the FT markets site and reading it off the tearsheet URL. London listings are quoted in pence, so check the currency field. Examples: 'AAPL:NSQ', 'SHEL:LSE', 'BMW:GER'. Default is 'AAPL:NSQ'.

## `maxItems` (type: `integer`):

Maximum number of instruments to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every instrument given.

## Actor input object example

```json
{
  "instruments": [
    "AAPL:NSQ",
    "VOD:LSE"
  ],
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

One item per requested input, in the default dataset.

# 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 = {
    "instruments": [
        "AAPL:NSQ",
        "VOD:LSE"
    ],
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/ft-markets-scraper").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 = {
    "instruments": [
        "AAPL:NSQ",
        "VOD:LSE",
    ],
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/ft-markets-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "instruments": [
    "AAPL:NSQ",
    "VOD:LSE"
  ],
  "maxItems": 0
}' |
apify call publicmoney/ft-markets-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicmoney/ft-markets-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zFZIoo5oD0275nPDj/builds/jsMEi1nXh1JoGu4Fq/openapi.json