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 high and low 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	Memory-safe 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 current local run produced the following shape. Quote values change with the source.

{
  "ticker": "AAPL",
  "exchange": "NASDAQ",
  "instrumentName": "Apple Inc",
  "instrumentId": "/m/07zmbvf",
  "country": "US",
  "currency": "USD",
  "price": 313.45,
  "priceChange": 3.5500183,
  "priceChangePercent": 1.1455368,
  "marketTimestamp": "2026-08-27T04:17:30.000Z",
  "marketTimezone": "America/New_York",
  "marketContext": {
    "previousClose": 309.9
  },
  "chartRange": "1M",
  "chartInterval": "1d",
  "chart": [
    {
      "date": "2026-08-26T16:00:00-04:00",
      "open": 310.3,
      "close": 313.45,
      "high": 315.43,
      "low": 308.8,
      "volume": 34024487
    }
  ],
  "sourceUrl": "https://www.google.com/finance/quote/AAPL:NASDAQ?hl=en",
  "scrapedAt": "2026-08-27T04:18:00.000Z"
}

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

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 for each validated quote record saved to the dataset;
• no quote event for invalid, duplicate, empty, or 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.

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 are listed in logs. A run fails when no target yields a valid record.

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 to keep direct HTTP runs reliable within the 256 MB memory allocation.

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 bounded retries. Invalid quote URLs and deterministic not-found responses are not retried indefinitely.

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.

The user controls the input, schedule, retention, export, and downstream processing.

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.