Google Finance Stock Quotes Scraper

Collect Google Finance stock quotes by ticker and exchange for portfolio snapshots, price monitoring, and market-data analysis.

The Actor returns one typed record per instrument with identity, current quote context, available market metrics, optional one-month daily OHLCV chart points, the canonical Google Finance source URL, and extraction timestamps.

It accepts both TICKER:EXCHANGE pairs and public Google Finance quote URLs. You can run a one-off batch, schedule recurring snapshots in Apify Console, or call it from an API workflow.

What does this Google Finance scraper extract?

Each successful instrument produces one dataset row.

Data group	Fields
Identity	ticker, exchange, instrument name, Google instrument ID, country
Current quote	currency, price, absolute change, percentage change
Market timing	quote timestamp and market timezone
Market context	open, high, low, previous close, market cap, volume, average volume, P/E, 52-week bounds, dividend yield, quarterly dividend, EPS, beta, shares outstanding, ex-dividend date when exposed
Chart	up to 31 newest one-month daily OHLCV points
Provenance	canonical Google Finance URL and Actor scrape timestamp

Google does not expose every metric for every security. Optional fields may therefore be absent while the required instrument identity and price remain available.

Who is it for?

• Portfolio operators who need a repeatable daily snapshot of selected public instruments.
• Analysts comparing current quote context with recent daily chart points.
• Data engineers building a normalized input for warehouses, spreadsheets, dashboards, or alerts.
• Developers who prefer a dataset/API response over maintaining Google Finance page parsing.
• Researchers collecting source-linked observations for reproducible market studies.

This Actor is a quote collector, not a broker, trading system, or investment-advice service.

Why use this Actor?

The input is intentionally explicit: every symbol includes its exchange, which avoids guessing between identically named instruments.

The output is normalized rather than raw HTML. One quote record carries its source URL and two useful timestamps so downstream systems can distinguish the market timestamp from the scrape time.

Chart extraction is bounded to the public one-month daily series. This keeps records useful for monitoring without claiming arbitrary historical coverage.

Duplicate TICKER:EXCHANGE inputs are removed before requests are made and charged.

Get started

1. Open the Actor input in Apify Console.
2. Add symbols such as AAPL:NASDAQ and MSFT:NASDAQ.
3. Keep Include one-month chart data enabled if you need OHLCV points.
4. Set the maximum quote count and conservative request concurrency.
5. Start the run.
6. Open the default dataset and export JSON, CSV, Excel, XML, or another supported format.
7. To monitor a portfolio, create an Apify schedule and compare records by ticker, exchange, and scrapedAt downstream.

A small input is the best first run. Confirm the exchange code on the instrument's Google Finance page before scaling a portfolio.

Input parameters

Field	Type	Default	Purpose
symbols	string array	none	Instruments in TICKER:EXCHANGE format
startUrls	URL array	none	Public google.com/finance/quote/... URLs
includeChart	boolean	true	Include one-month daily OHLCV points
maxChartPoints	integer, 1–31	31	Keep the newest chart points per quote
maxItems	integer, 1–1000	100	Maximum unique instruments processed
maxConcurrency	integer, fixed at 1	1	Sequential quote-page requests
proxyConfiguration	object	direct connection	Optional Apify Proxy settings

At least one symbol or URL is required. You can combine both routes in one run. The Actor normalizes URLs to canonical English Google Finance quote pages and deduplicates them with symbol inputs.

Minimal quote input

{
  "symbols": ["AAPL:NASDAQ", "MSFT:NASDAQ"],
  "includeChart": false,
  "maxItems": 2
}

Portfolio input with chart points

{
  "symbols": [
    "AAPL:NASDAQ",
    "MSFT:NASDAQ",
    "GOOGL:NASDAQ",
    "NVDA:NASDAQ"
  ],
  "includeChart": true,
  "maxChartPoints": 10,
  "maxItems": 4,
  "maxConcurrency": 1
}

Direct Google Finance URL input

{
  "startUrls": [
    { "url": "https://www.google.com/finance/quote/AAPL:NASDAQ" }
  ],
  "includeChart": true,
  "maxChartPoints": 31,
  "maxItems": 1
}

Output example

A local quote snapshot illustrates the following shape. Market-context values below were observed on October 10, 2026; quote values change with the source.

{
  "ticker": "AAPL",
  "exchange": "NASDAQ",
  "instrumentName": "Apple Inc",
  "instrumentId": "/m/07zmbvf",
  "country": "US",
  "currency": "USD",
  "price": 336.64,
  "priceChange": -3.7799988,
  "priceChangePercent": -1.1103927,
  "marketTimestamp": "2026-10-10T00:30:00.000Z",
  "marketTimezone": "America/New_York",
  "marketContext": {
    "previousClose": 340.42,
    "open": 331.70,
    "high": 338.61,
    "low": 330.70,
    "marketCap": 4910000000000,
    "volume": 37880000,
    "averageVolume": 40520000,
    "peRatio": 38.59,
    "week52High": 345.34,
    "week52Low": 243.42,
    "dividendYield": 0.32,
    "quarterlyDividend": 0.27,
    "eps": 8.72,
    "beta": 1.07,
    "sharesOutstanding": 14590000000,
    "exDividendDate": "2026-08-10"
  },
  "chartRange": "1M",
  "chartInterval": "1d",
  "chart": [
    {
      "date": "2026-10-09T16:00:00-04:00",
      "open": 331.7,
      "close": 336.64,
      "high": 338.61,
      "low": 330.7,
      "volume": 37881200
    }
  ],
  "sourceUrl": "https://www.google.com/finance/quote/AAPL:NASDAQ?hl=en",
  "scrapedAt": "2026-10-10T10:39:53.613Z"
}

The complete chart array can contain up to the requested 31 newest daily points. Set includeChart to false for a smaller quote-only record.

dividendYield uses percentage points (0.32 means 0.32%, not 32%). sharesOutstanding, capitalization and volumes expand K/M/B/T into numbers. quarterlyDividend and eps retain displayed monetary amounts; no currency is inferred for missing source data. beta is unitless. exDividendDate is YYYY-MM-DD only when the source supplies an unambiguous full date. Unavailable or malformed metrics are omitted. The Market context dataset view makes valuation fields easier to browse.

Inspect the batch outcome

Every valid batch writes RUN_SUMMARY to the run's default key-value store. It reports unique, processed, succeeded, failed, capped (excluded by maxItems), unprocessed, and budget-skipped targets, charge counts, stop reason, and bounded per-target failure categories. Invalid input can fail before a batch summary exists. Failure records contain canonical symbols and categories, not raw responses or URL queries. Quote datasets contain only quote rows, never error rows.

const summary = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('RUN_SUMMARY');
console.log(summary.value.stopReason, summary.value.failures);

stopReason is completed, max_items, charge_limit, charge_error, or storage_error. Mixed retrieval failures preserve valid saved quotes; an all-failed retrieval batch fails. Budget exhaustion stops cleanly, even if no quote can be afforded. Compare succeeded with unique before using a snapshot as a complete portfolio. processed = succeeded + failed + budgetSkipped and unique = capped + unprocessed + processed.

How much does it cost to collect Google Finance stock quotes?

The Actor uses pay-per-event pricing:

• one start event per run;
• one quote event before saving each validated quote record;
• no quote event for invalid, duplicate, empty, or retrieval-failed targets;
• chart points and market-context fields are included in the quote event and are not charged separately.

The current event prices are:

Apify plan tier	Quote event
FREE	$0.0092506
BRONZE	$0.008044
SILVER	$0.0062743
GOLD	$0.0048264
PLATINUM	$0.0032176
DIAMOND	$0.0022523

The one-time start event is $0.005 on every tier. At BRONZE rates, one successful quote costs about $0.0130 including start, 25 successful quotes cost about $0.2061, and 100 successful quotes cost about $0.8094. Chart points and market-context fields have no separate event charge.

The Actor checks PPE event capacity before requesting another target and checks actual charged count before emitting a quote. It never retries charging because storage failed. Charge errors or storage errors stop the run rather than silently continuing. A rare storage failure after a successful charge may leave a charged quote unsaved (or an ambiguous write); chargedNotSaved exposes this and the run fails. Local non-PPE runs do not require simulated paid charges.

Apify plan tiers have different quote-event rates. The Console pricing tab is the authoritative current price before a run. Small test inputs help you verify output and estimate a recurring schedule before processing a large list.

Schedule portfolio snapshots

Use Apify Schedules to run the same input hourly, daily, or weekly. Each run creates a separate dataset snapshot.

For change tracking:

1. use a stable list of TICKER:EXCHANGE values;
2. keep the schedule timezone explicit;
3. store price, marketTimestamp, and scrapedAt together;
4. compare the newest observation with the previous successful observation downstream;
5. trigger your own notification only after validating the source timestamp and market status.

The Actor does not remain online between runs and does not send investment alerts by itself.

Export and integrate the data

The default dataset works with standard Apify integrations and exports.

Common workflows include:

• send quote rows to Google Sheets for a lightweight portfolio log;
• load JSON or CSV into a warehouse for time-series comparisons;
• connect Make or Zapier to process finished datasets;
• call a webhook when a scheduled Actor run finishes;
• join ticker and exchange against internal instrument metadata;
• use chart arrays in a downstream volatility or trend calculation.

Keep market data timestamps in your destination. Do not substitute ingestion time for the timestamp attached to the source quote.

Run with the Apify API

Replace <APIFY_TOKEN> with your token. Keep tokens in a secret manager rather than source code.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~google-finance-market-data-scraper/runs?token=<APIFY_TOKEN>&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"symbols":["AAPL:NASDAQ","MSFT:NASDAQ"],"includeChart":true,"maxChartPoints":10}'

Fetch the resulting dataset with the defaultDatasetId returned by the run.

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-finance-market-data-scraper').call({
  symbols: ['AAPL:NASDAQ', 'MSFT:NASDAQ'],
  includeChart: true,
  maxChartPoints: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/google-finance-market-data-scraper').call(
    run_input={
        'symbols': ['AAPL:NASDAQ', 'MSFT:NASDAQ'],
        'includeChart': True,
        'maxChartPoints': 10,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/google-finance-market-data-scraper"

Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use the equivalent HTTP MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/google-finance-market-data-scraper"
    }
  }
}

Example prompts:

• "Get current Google Finance quote records for AAPL:NASDAQ and MSFT:NASDAQ without chart data."
• "Collect ten daily chart points for NVDA:NASDAQ and summarize the range."
• "Run my four-ticker portfolio input and return the dataset URL."

AI-generated financial interpretation should be independently verified.

Data quality and validation

The Actor requires the embedded result to match the requested ticker and exchange and contain a finite numeric price. It will not emit guessed values when Google changes the page or returns another instrument.

A successful record is charged and stored only after validation. Duplicate targets are requested once. If some upstream targets fail while others succeed, the successful quote records remain available and failures appear in RUN_SUMMARY. An all-failed retrieval batch fails; budget exhaustion stops cleanly with charge_limit.

Limits and source behavior

• The source is public Google Finance quote pages in English (hl=en).
• Chart coverage is the one-month daily OHLCV series exposed on the page, not arbitrary history.
• Chart points can be absent for instruments or market types where Google does not expose that series.
• Quote timing varies by market and instrument; the Actor does not promise exchange-grade real-time feeds.
• Google may change embedded payloads, labels, availability, or anti-automation behavior.
• A valid ticker on another exchange must include the correct exchange code.
• The maximum input scope is 1,000 unique instruments per run.
• Quote pages are processed sequentially. The default memory allocation is 512 MB, validated with a 1,000-instrument chart-enabled local replay; network latency still determines how many targets fit the selected run timeout.

Proxy and retry behavior

Direct HTTP is the default because it currently returns the public structured page. Optional Apify Proxy configuration is available for users who require their own routing policy.

Transient network errors, HTTP 429 responses, and server errors receive at most three attempts with bounded exponential backoff and jitter. HTTP 400/404 and parsing failures are not retried. Invalid inputs fail before requests. Charge and storage phases are separate and never trigger retrieval retries.

A proxy can change run cost. Test the exact routing mode and geography you intend to use before scheduling a large recurring portfolio.

Legality and responsible use

Collect only public data you are permitted to use. Review Google terms, Apify policies, market-data licensing obligations, and laws applicable to your jurisdiction and intended use.

Do not use scraped quotes as the sole source for executing trades, valuing regulated products, or making safety-critical financial decisions. Confirm material values with an authorized market-data source.

This independent Actor is not affiliated with or endorsed by Google. It uses deterministic extraction, not an AI model; the optional MCP/AI assistant examples below are downstream user workflows, not Actor subprocessors. Public ticker/exchange paths are requested from Google Finance. If enabled, Apify Proxy carries those public requests; the Actor creates no external cache. Run datasets and logs follow your Apify account retention and deletion settings. The user controls the input, schedule, retention, export, and downstream processing.

Diagnostic privacy

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. Reports contain bounded failure categories, not raw page bodies or proxy credentials.

Troubleshooting

Why does AAPL fail?

Symbols must include an exchange. Use AAPL:NASDAQ, not AAPL.

Why did a Google Finance URL fail validation?

Use a public quote URL shaped like https://www.google.com/finance/quote/AAPL:NASDAQ. Search pages, portfolio pages, and non-Google URLs are not supported inputs.

Why is chart empty?

Confirm includeChart is true. Google may not expose the one-month daily OHLCV payload for every instrument type. The quote can still be valid when chart data is unavailable.

Why is a market metric missing?

Google displays different metric cards by instrument. Optional fields such as P/E or volume are omitted when not exposed rather than fabricated.

Why did the whole run fail?

The Actor fails when every unique target fails validation or retrieval. Inspect the log for ticker/exchange mistakes, response statuses, or source-layout messages. Retry only after correcting the input or a transient source problem.

FAQ

Does it search by company name?

No. Inputs are explicit ticker/exchange pairs or quote URLs. This avoids ambiguous company-name matching.

Does it scrape news or financial statements?

No. This Actor's bounded product is quote identity, current market context, and optional one-month daily chart data.

Can I monitor prices continuously?

Create an Apify schedule for periodic snapshots. The Actor performs bounded runs and does not maintain a continuous connection between them.

Is this a Google API?

No. It parses public Google Finance quote-page data and can be called through the Apify API.

Are duplicate symbols charged twice?

No. Canonically identical ticker/exchange inputs are deduplicated before requests and quote events.

Can I export CSV or Excel?

Yes. Use the standard dataset export controls or API formats. Nested chart points are most naturally preserved in JSON; tabular exports may serialize that array.

Is the data investment advice?

No. The output is source-linked public market context for automation and analysis, not a recommendation.

Related Automation Lab Actors

For broader market screening rather than explicit Google Finance quote collection, consider the TradingView Stock Screener Scraper.

Choose this Actor when the source-specific requirement is Google Finance and the core unit is one ticker/exchange quote record with optional one-month chart data.