# Google Finance Stock Quotes Scraper (`automation-lab/google-finance-market-data-scraper`) Actor

Extract public Google Finance quotes, market context, and one-month daily OHLCV chart points by ticker for recurring portfolio tracking.

- **URL**: https://apify.com/automation-lab/google-finance-market-data-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.83 / 1,000 quote extracteds

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

## 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

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

#### Portfolio input with chart points

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

#### Direct Google Finance URL input

```json
{
  "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.

```json
{
  "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

```bash
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

```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

```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:

```bash
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:

```json
{
  "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](https://apify.com/automation-lab/tradingview-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.

# Actor input Schema

## `symbols` (type: `array`):

Symbols in TICKER:EXCHANGE format. Use the exchange shown by Google Finance, for example AAPL:NASDAQ or MSFT:NASDAQ.

## `startUrls` (type: `array`):

Optional public Google Finance quote URLs. You can combine these with symbols; duplicates are removed.

## `includeChart` (type: `boolean`):

Include daily OHLCV chart points exposed on the Google Finance quote page.

## `maxChartPoints` (type: `integer`):

Keep the newest daily points from the one-month chart, up to 31 per instrument.

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

Maximum number of unique instruments to process in this run.

## `maxConcurrency` (type: `integer`):

Google Finance requests are processed sequentially to stay reliable within the 256 MB HTTP allocation.

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

Optional Apify Proxy configuration. Direct HTTP is used when omitted.

## Actor input object example

```json
{
  "symbols": [
    "AAPL:NASDAQ",
    "MSFT:NASDAQ"
  ],
  "startUrls": [
    {
      "url": "https://www.google.com/finance/quote/AAPL:NASDAQ"
    }
  ],
  "includeChart": true,
  "maxChartPoints": 20,
  "maxItems": 4,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Typed Google Finance quotes with market context, optional daily chart points, source URLs and timestamps.

# 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 = {
    "symbols": [
        "AAPL:NASDAQ",
        "MSFT:NASDAQ"
    ],
    "startUrls": [
        {
            "url": "https://www.google.com/finance/quote/AAPL:NASDAQ"
        }
    ],
    "includeChart": true,
    "maxChartPoints": 20,
    "maxItems": 4,
    "maxConcurrency": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-finance-market-data-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 = {
    "symbols": [
        "AAPL:NASDAQ",
        "MSFT:NASDAQ",
    ],
    "startUrls": [{ "url": "https://www.google.com/finance/quote/AAPL:NASDAQ" }],
    "includeChart": True,
    "maxChartPoints": 20,
    "maxItems": 4,
    "maxConcurrency": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-finance-market-data-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 '{
  "symbols": [
    "AAPL:NASDAQ",
    "MSFT:NASDAQ"
  ],
  "startUrls": [
    {
      "url": "https://www.google.com/finance/quote/AAPL:NASDAQ"
    }
  ],
  "includeChart": true,
  "maxChartPoints": 20,
  "maxItems": 4,
  "maxConcurrency": 1
}' |
apify call automation-lab/google-finance-market-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/google-finance-market-data-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/yjdK6v1GeEUzWoeXe/builds/YTNVaCjDPVyupcPjm/openapi.json