MarketWatch API

A MarketWatch API that returns one quote row per ticker — AAPL, MSFT, BRK.B — with latest price, change and percent change, which session it came off, previous close, open, day and 52-week ranges, volume and 65-day average, market cap, P/E, EPS, shares outstanding, float, beta, dividend and yield. Numbers are read at full precision from the page’s machine-readable attributes, not from the rounded display.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Get my free API key See the request

$0.001 per delivered quote · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/marketwatch_quote/run

$ curl $QD/marketwatch_quote/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"tickers": ["AAPL"], "max_results": 1}'
{ "status": "done", "count": 1,
  "results": [
    {
      "ticker": "…",
      "requested_ticker": "…",
      "name": "…",
      "exchange": "…" } ],
  "cost": 0.001 }
# 1 quote × $0.001 · nothing delivered, nothing charged

MarketWatch API: tickers and country in, a residential exit in the middle, delivered rows with rank, ticker and requested_ticker on the right, $0.001 per quote. — You send tickers and country; the run goes out through a residential exit and comes back as quotes with rank, ticker and requested_ticker — 31 fields on every row — and you are billed $0.001 for each quote actually delivered, nothing for a run that delivers none.

$0.001 / quote2,000 quotes on the free $2 every month

Semantic inputtickers, country, max_results — no URL lists

Up to 25quotes per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Try it

MarketWatch stock quote, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

What a MarketWatch API does

MarketWatch ships no hydration payload for a quote and the one JSON API behind the page needs an entitlement token that appears nowhere in the HTML, so there is no keyless request to make. Three sources are read instead, in descending order of durability: the meta tags in the head for the identity fields — symbol, instrument type, exchange, currency — which are rendered for search engines and least likely to move; the range-bar custom elements, which carry open, day low and day high as attributes at full precision (344.5699 where the page displays 344.57) along with MarketWatch’s own instrument id; and the Key Data list, read as a label-to-value map for market cap, P/E, EPS, beta and float.

What is deliberately not read is as important. The head also carries a price, a change and a quote time, and none of the three is used: in extended hours they stamp the previous regular close, so they would silently back-date the row by a session. The session the price came off — regular, premarket, after hours or closed — is delivered on the row so the number is never ambiguous. Key Data is read by label and never by position, so a page that drops a row does not shift every field down one.

Limits, in plain numbers

Everything that bounds one run of this collector. No hidden throttles.

Max per run

25 quotes

Price

$0.001 / quote

Per 1,000

$1.00

Failed runs

Free zero rows, zero charge

Free every month

$2 no card

Rate limit

60 req/min on the free tier

What one quote looks like

Every delivered quote carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position in the delivered rows.
`ticker`	string	Ticker symbol as the quote page states it.
`requested_ticker`	string	The symbol you asked for — differs from `ticker` when MarketWatch resolved it to another listing.
`name`	string · nullable	Company name.
`exchange`	string · nullable	Listing exchange, e.g. "U.S.: Nasdaq".
`exchange_iso`	string · nullable	ISO 10383 MIC, e.g. XNAS.
`currency`	string · nullable	Price currency.
`instrument_type`	string · nullable	Instrument type as MarketWatch classifies it, e.g. Stock.
`instrument_id`	string · nullable	MarketWatch's internal instrument id. Stable across ticker changes; the key rows are de-duplicated on.
`price`	number · nullable	Latest printed price as of `quote_time`, not as of the request — the page is CDN-cached. In premarket or after hours this is the extended-hours print, not the last regular close; `session` says which.
`change`	number · nullable	Change against the previous close, in price terms.
`change_percent`	number · nullable	Change against the previous close, in percent (0.45 means +0.45%).
`session`	string · nullable	Which tape `price` came off: open, premarket, after_hours or closed.
`quote_time`	string · nullable	As-of timestamp exactly as MarketWatch states it, including its exchange timezone, e.g. "Sep 2, 2026 8:20 a.m. EDT". This is how fresh the row actually is.
`previous_close`	number · nullable	Previous regular-session close, read from the close table MarketWatch renders alongside an extended-hours quote. Null when the page does not carry that table.
`open`	number · nullable	Regular-session open. In premarket or after hours this is the LAST COMPLETED session's open, the same tape as `volume` — not the session `price` came off.
`day_low`	number · nullable	Regular-session low, at the page's full precision. In extended hours it belongs to the last completed session, so it is not a bound on `price`.
`day_high`	number · nullable	Regular-session high, at the page's full precision. In extended hours it belongs to the last completed session, so it is not a bound on `price`.
`week52_low`	number · nullable	52-week low, at the page's full precision.
`week52_high`	number · nullable	52-week high, at the page's full precision.
`volume`	integer · nullable	Regular-session volume. Not the extended-hours tape MarketWatch shows as "Before/After Hours Volume".
`avg_volume_65d`	integer · nullable	65-day average volume.
`market_cap`	number · nullable	Market capitalisation, suffix expanded ($4.75T becomes 4750000000000).
`pe_ratio`	number · nullable	Price/earnings ratio. Null when MarketWatch prints N/A, which it does for loss-making companies.
`eps`	number · nullable	Earnings per share. Negative for loss-making companies.
`shares_outstanding`	number · nullable	Shares outstanding, suffix expanded.
`public_float`	number · nullable	Public float, suffix expanded.
`beta`	number · nullable	Beta.
`dividend`	number · nullable	Dividend per share as most recently declared.
`dividend_yield_percent`	number · nullable	Dividend yield in percent (0.33 means 0.33%).
`url`	string	Quote page the row was read from.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`tickers`	array	yes	US-listed ticker symbols as MarketWatch spells them, e.g. AAPL, MSFT, BRK.B.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many quotes to deliver at most (1–25). You pay only for delivered quotes.

Pricing

MarketWatch API pricing

$0.001 per delivered quote. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 quotes before you spend anything.

$0.001per delivered quote$1 per 1,000 delivered quotes

2,000 quoteson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/marketwatch_quote/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/marketwatch_quote/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tickers":["AAPL"],"max_results":1}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/marketwatch_quote/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "tickers": [
            "AAPL"
        ],
        "max_results": 1
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/marketwatch_quote/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"tickers":["AAPL"],"max_results":1}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the marketwatch_quote collector with tickers=["AAPL"] and max_results=1

What people build with the MarketWatch API

Three shapes of work this endpoint was designed around.

Watchlist snapshots

Up to 25 tickers per run, one typed row each, on a schedule — a quote feed without an exchange contract.

Fundamentals at a glance

Market cap, P/E, EPS, float, beta and yield per ticker, read from the same page a person would check.

Extended-hours monitoring

session says whether the price is premarket, after hours or the close, so a pre-open scan is not mistaken for yesterday.

MarketWatch API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Precision	The rounded number on screen	The attribute value: 344.5699
Quote time	The head’s stamp — the previous close in extended hours	The session stated, the stale fields ignored
Key data	Read by position — shifts when a row is missing	Read by label
Access	An entitlement token you do not have	Public page, no key

What people search for

Live autocomplete demand around MarketWatch stock quote, pulled with our own Keyword ideas collector.

MarketWatch API: the POST to /v1/scraper/collectors/marketwatch_quote/run with tickers and country on the left, and the JSON envelope on the right with 1 quotes and usage.cost_usd $0.001. — The same call you would paste into a terminal: a Bearer key, tickers and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many quotes arrived and usage.cost_usd is $0.001, which is 1 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the MarketWatch API.

Something else? Ask us →

Is this real-time data?

It is what MarketWatch publishes on the quote page at the moment of the fetch, with the session stated. It is not an exchange feed and not for trading systems; it is a quote snapshot with fundamentals, read at full precision.

Does MarketWatch have an API?

Not a public one: the JSON service behind the page needs an entitlement token the page never exposes. This collector reads the public quote page instead.

Which tickers work?

The symbols MarketWatch resolves — US equities including class shares like BRK.B. The row carries requested_ticker beside the resolved one so nothing is silently substituted.

Why might a fundamentals field be null?

Because the Key Data list did not state it for that instrument. Fields are read by label, so a missing one stays null instead of taking the next row’s value.

Is there a free MarketWatch API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered quotes on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 25 quotes — the maximum for this collector — costs $0.025 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the MarketWatch API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key