# Google Finance Scraper (`automation-lab/google-finance-scraper`) Actor

Extract Google Finance quotes, fundamentals, company profiles, quarterly and annual statements, related securities, and news. Export via API, JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/google-finance-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

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

Extract **Google Finance stock quotes, fundamentals, company profiles, financial statements, related securities, and current news** without an API key.

Give the Actor ticker/exchange pairs such as `AAPL:NASDAQ` or canonical Google Finance quote URLs.
It returns one normalized portfolio-ready record per security in JSON, CSV, Excel, XML, or RSS.

- 📈 Refresh a watchlist or portfolio on a schedule.
- 🧾 Collect quarterly and annual revenue, net income, EPS, and margins.
- 📰 Monitor current company news with source links.
- ⚡ Use lightweight HTTP extraction instead of paying browser overhead.
- 🔑 No Google login, private account, or API key is required.

### What does Google Finance Scraper do?

Google Finance Scraper turns public [Google Finance](https://www.google.com/finance/) quote pages into structured market-data records.

For each requested ticker it extracts:

- identity and exchange;
- current price and price movement;
- open, high, low, volume, and market capitalization;
- valuation and dividend metrics;
- company profile facts;
- quarterly and annual financial summaries;
- related securities;
- recent news headlines and source URLs.

The Actor accepts batches, removes duplicate symbols, and keeps an error record for an individual bad symbol without discarding successful portfolio results.

### Who is Google Finance Scraper for?

**Portfolio and wealth-tech teams**

- Refresh quote snapshots for internal dashboards.
- Enrich holdings with valuation ratios and company descriptions.
- Schedule daily or intraday monitoring runs.

**Financial analysts and researchers**

- Compare revenue, net income, EPS, and margins across periods.
- Collect related tickers for peer research.
- Send current company news into a research queue.

**Data engineers**

- Load consistent numeric fields into a warehouse.
- Use one record per ticker for simple upserts.
- Trigger runs through API, webhooks, Make, or Zapier.

**Developers and AI-agent builders**

- Use an API-like extraction layer without maintaining selectors.
- Call the Actor through Apify MCP.
- Export data into notebooks, apps, and automated reports.

### Why use this Google Finance data extractor?

- ✅ **No API key:** reads public anonymous quote pages.
- ✅ **Batch portfolio input:** mix ticker pairs and quote URLs.
- ✅ **Deduplication:** `aapl:nasdaq` and its canonical URL become one request.
- ✅ **Typed output:** K/M/B/T abbreviations become JSON numbers.
- ✅ **Bounded retries:** transient responses are retried conservatively.
- ✅ **Per-symbol errors:** one unavailable symbol does not erase good records.
- ✅ **Low overhead:** HTTP-first extraction runs with 256 MB memory.
- ✅ **Apify platform:** scheduling, datasets, API, webhooks, and integrations are included.

### What Google Finance data can you extract?

| Category | Example fields |
|---|---|
| Identity | `ticker`, `exchange`, `companyName`, `currency`, `sourceUrl` |
| Quote | `price`, `priceChange`, `priceChangePercent`, `marketStatus` |
| Trading | `open`, `high`, `low`, `volume`, `averageVolume`, `marketCap` |
| Fundamentals | `peRatio`, `eps`, `beta`, `sharesOutstanding` |
| Dividends | `dividendYieldPercent`, `quarterlyDividend`, `exDividendDate` |
| Company | `ceo`, `employees`, `founded`, `headquarters`, `sector`, `description` |
| Financials | quarterly and annual `revenue`, `netIncome`, `eps`, `netProfitMargin` |
| Related | ticker, exchange, company, price, change percentage, quote URL |
| News | headline, publisher, relative publication time, article URL |
| Operations | `status`, `error`, `scrapedAt` |

Optional fields are omitted when Google Finance does not publish them for that security.
They are never replaced with misleading zero values.

### How much does it cost to scrape Google Finance?

Google Finance Scraper uses **pay-per-event** pricing.
A run currently has a $0.005 start event and a tiered price per successfully extracted security.
Failed symbols are not charged as successful securities.

| Apify plan | Price per security |
|---|---:|
| Free | $0.0002454 |
| Starter / Bronze | $0.00021339 |
| Scale / Silver | $0.00016645 |
| Business / Gold | $0.00012804 |

Higher plans receive additional volume discounts.
Platform compute is included in pay-per-event pricing.

**Illustrative costs at Free-tier pricing**

| Workflow | Securities | Approximate event cost |
|---|---:|---:|
| Single quote lookup | 1 | $0.00525 |
| Small watchlist | 10 | $0.00745 |
| Portfolio refresh | 100 | $0.02954 |
| Large symbol batch | 1,000 | $0.25040 |

These examples include the $0.005 run-start event and use the Free-tier per-security price.

### How to scrape Google Finance stock data

1. Open [Google Finance Scraper](https://apify.com/automation-lab/google-finance-scraper).
2. Add one or more `TICKER:EXCHANGE` values.
3. Choose whether to include financials, news, and related securities.
4. Keep concurrency low for a first run.
5. Click **Start**.
6. Review the dataset table.
7. Export JSON, CSV, Excel, XML, or RSS, or connect an integration.

A minimal input is:

```json
{
  "symbols": ["AAPL:NASDAQ"]
}
````

A portfolio input is:

```json
{
  "symbols": ["AAPL:NASDAQ", "MSFT:NASDAQ", "BMW:ETR"],
  "maxNewsItems": 5,
  "maxRelatedSecurities": 5
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `symbols` | string\[] | none (UI prefill: `AAPL:NASDAQ`) | Ticker and exchange pairs |
| `startUrls` | Request\[] | none | Canonical Google Finance quote URLs |
| `includeFinancials` | boolean | `true` | Add quarterly and annual summaries |
| `includeNews` | boolean | `true` | Add current news stories |
| `maxNewsItems` | integer | `10` | Maximum news records per security, 0–50 |
| `includeRelated` | boolean | `true` | Add related securities |
| `maxRelatedSecurities` | integer | `10` | Maximum related records, 0–30 |
| `maxConcurrency` | integer | `3` | Parallel quote requests, 1–10 |
| `proxyConfiguration` | object | direct | Optional Apify Proxy settings |

You may use both `symbols` and `startUrls`.
Duplicates are normalized by ticker and exchange before requests begin.

### Supported ticker and URL formats

Use the exchange shown by Google Finance:

```text
AAPL:NASDAQ
MSFT:NASDAQ
SPY:NYSEARCA
BMW:ETR
VOD:LON
```

Canonical URL input also works:

```text
https://www.google.com/finance/quote/AAPL:NASDAQ
https://www.google.com/finance/quote/BMW:ETR?hl=en
```

URLs outside `google.com/finance/quote/` fail closed.
A generic Google search URL cannot bypass this scope check.

### Google Finance output example

```json
{
  "status": "ok",
  "ticker": "AAPL",
  "exchange": "NASDAQ",
  "companyName": "Apple Inc",
  "sourceUrl": "https://www.google.com/finance/quote/AAPL:NASDAQ?hl=en",
  "currency": "USD",
  "price": 333.74,
  "priceChange": 0.48,
  "priceChangePercent": 0.14,
  "open": 331.98,
  "high": 334.99,
  "low": 329,
  "marketCap": 4900000000000,
  "volume": 63410000,
  "peRatio": 40.37,
  "eps": 8.27,
  "sector": "Computers, Peripherals, and Software",
  "quarterlyFinancials": [
    {
      "period": "Jun 2026",
      "revenue": 111184000000,
      "netIncome": 29578000000,
      "eps": 2.01,
      "netProfitMargin": 26.6
    }
  ],
  "news": [
    {
      "title": "Example company headline",
      "source": "Example Publisher",
      "publishedAgo": "1 hour ago",
      "url": "https://example.com/article"
    }
  ],
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Actual market values change continuously.
Treat the example as a field-shape reference, not a live quote.

### Financial statement coverage

The Actor reads Google Finance's embedded statement dataset.
It returns up to eight recent quarterly periods and six annual periods.

Each period contains:

- `period`;
- `revenue`;
- `netIncome`;
- `eps`;
- `netProfitMargin`.

These fields provide a compact comparison layer without claiming every accounting line shown by every issuer.
Financial availability varies for stocks, funds, currencies, indices, and crypto.

### Tips for reliable portfolio refreshes

- 🧪 Start with one or two known symbols before submitting a large portfolio.
- 🏷️ Always include the exchange; tickers alone can be ambiguous.
- 🌐 Use canonical quote URLs when an instrument has an unusual symbol.
- ⚙️ Keep `maxConcurrency` near the default for scheduled runs.
- 📰 Reduce `maxNewsItems` if you only need quote and fundamental snapshots.
- 🧾 Disable financials for asset types that do not publish corporate statements.
- 🔁 Use a daily schedule and stable ticker list for warehouse upserts.
- 🚨 Inspect records with `status: "error"` before replacing prior good data.

### Integrations and automation workflows

**Google Finance Scraper → Google Sheets**

Schedule a morning run and replace a sheet tab with price, market cap, P/E, and EPS for a team watchlist.

**Google Finance Scraper → Slack or Discord**

Use a webhook to compare `priceChangePercent` against a threshold and post large-move alerts.

**Google Finance Scraper → Make or Zapier**

Trigger a run from a CRM or portfolio table, then route news URLs into a research-review workflow.

**Google Finance Scraper → BigQuery, Snowflake, or PostgreSQL**

Upsert by `ticker` plus `exchange` and store `scrapedAt` for time-series snapshots.

**Scheduled monitoring**

Use Apify schedules for daily fundamentals, weekly statement refreshes, or market-hour quote snapshots.

### Using the Apify API with Node.js

```javascript
import { ApifyClient } from 'apify-client';

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

The returned dataset ID is stable for the run and can be exported in multiple formats.

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/google-finance-scraper').call(run_input={
    'symbols': ['AAPL:NASDAQ', 'BMW:ETR'],
    'includeNews': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Use environment variables or a secret manager for tokens.

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~google-finance-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "symbols": ["AAPL:NASDAQ", "MSFT:NASDAQ"],
    "maxNewsItems": 5
  }'
```

Poll the returned run or use a webhook to continue when it succeeds.

### Use Google Finance Scraper with AI agents via MCP

Google Finance Scraper works as a tool for assistants that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

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

For Claude Desktop, Cursor, or VS Code:

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

After OAuth authentication, try these example prompts:

- “Use `automation-lab/google-finance-scraper` to compare AAPL:NASDAQ and MSFT:NASDAQ fundamentals.”
- “Fetch BMW:ETR quarterly and annual revenue, net income, and recent news.”
- “Refresh my five-symbol watchlist and flag price changes above three percent.”

### Is it legal to scrape Google Finance?

Scraping public web data is generally legal in many jurisdictions, but the rules depend on location, purpose, data type, and contractual obligations.

Use the Actor responsibly:

- collect only public information you are authorized to use;
- respect applicable terms, database rights, copyright, and rate limits;
- do not use personal data unlawfully;
- comply with financial-data licensing rules in your jurisdiction;
- seek legal advice for regulated or high-risk use cases.

This Actor is an extraction tool, not investment advice or a licensed real-time market-data feed.
Google Finance and Google are trademarks of Google LLC; this Actor is independent and unaffiliated.

### Limitations and data freshness

- Google controls the source markup and may change it.
- Quote delay and market status depend on the exchange and Google Finance.
- Some instruments do not expose company profiles, dividends, or statements.
- News availability varies by ticker, region, and time.
- Historical chart series are not included in v1.
- The Actor validates identity and price, but it does not guarantee exchange-grade real-time delivery.
- Direct HTTP is the default; configure a proxy only when geography or routing requires it.

### Frequently asked questions

**Does this scrape real-time Google Finance prices?**

It extracts the current value displayed by Google Finance at request time.
Exchange-specific delays may apply, so use a licensed market feed for trading execution.

**How fast is a run?**

A small direct-HTTP watchlist usually completes quickly because no browser starts.
Duration scales mainly with ticker count, retries, and proxy routing.

**Do I need a Google Finance API key?**

No.
The Actor reads anonymous public quote pages and embedded page data.

**Can I submit only `AAPL` without an exchange?**

No.
Use `AAPL:NASDAQ` so the target is deterministic and cannot silently resolve to the wrong instrument.

**Why is a field missing?**

Google Finance does not publish every field for every asset type.
Missing optional values are omitted rather than converted to zero.

**Why did a symbol return an error record?**

Check the ticker/exchange pair on Google Finance, then retry with its canonical quote URL.
A delisted instrument, changed exchange code, challenge page, or temporary upstream response can cause an error.

**What happens if every symbol fails?**

The Actor exits with a failed status after preserving diagnostic records.
This prevents an empty or fully broken extraction from looking successful in automation.

**How is this different from an official market-data API?**

This tool structures the public Google Finance surface and is convenient for research and monitoring.
A licensed API is more appropriate for guaranteed latency, redistribution rights, or order execution.

### Other financial and market-data scrapers

Build a broader research stack with other automation-lab tools:

- [TradingView Scraper](https://apify.com/automation-lab/tradingview-scraper) — screen global markets and instruments.
- [Stocktwits Scraper](https://apify.com/automation-lab/stocktwits-scraper) — collect investor messages and sentiment.
- [Yahoo Finance Scraper](https://apify.com/automation-lab/yahoo-finance-scraper) — extract Yahoo Finance market data.
- [SEC EDGAR Scraper](https://apify.com/automation-lab/sec-edgar-scraper) — collect public company filings.
- [CoinMarketCap Scraper](https://apify.com/automation-lab/coinmarketcap-scraper) — monitor crypto-market records.

Use only the tools needed for your workflow, keep first runs small, and validate source-specific licensing requirements.

### Support

If a run behaves unexpectedly, include:

- the run URL;
- the affected ticker and exchange;
- whether a proxy was enabled;
- the expected field;
- a link to the matching public Google Finance quote page.

That context makes source changes and ticker-specific cases faster to reproduce.

# Actor input Schema

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

Add one TICKER:EXCHANGE pair per entry, for example AAPL:NASDAQ or BMW:ETR.

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

Add canonical google.com/finance/quote/TICKER:EXCHANGE URLs. Other Google products and non-Google hosts are rejected.

## `includeFinancials` (type: `boolean`):

Extract up to eight quarterly and six annual revenue, net income, EPS, and margin records.

## `includeNews` (type: `boolean`):

Include current Google Finance news headlines, publishers, relative publication times, and source URLs.

## `maxNewsItems` (type: `integer`):

Limit current news stories saved inside each security record.

## `includeRelated` (type: `boolean`):

Include Google Finance related tickers with company, price, and percentage change.

## `maxRelatedSecurities` (type: `integer`):

Limit related-security records nested under each requested ticker.

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

Control how many quote pages are requested at once. Keep this conservative for stable scheduled portfolio refreshes.

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

Optionally route requests through Apify Proxy for geography or IP rotation. Direct HTTP is used when omitted.

## Actor input object example

```json
{
  "symbols": [
    "AAPL:NASDAQ"
  ],
  "startUrls": [],
  "includeFinancials": true,
  "includeNews": true,
  "maxNewsItems": 5,
  "includeRelated": true,
  "maxRelatedSecurities": 5,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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"
    ],
    "startUrls": [],
    "includeFinancials": true,
    "includeNews": true,
    "maxNewsItems": 5,
    "includeRelated": true,
    "maxRelatedSecurities": 5,
    "maxConcurrency": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-finance-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"],
    "startUrls": [],
    "includeFinancials": True,
    "includeNews": True,
    "maxNewsItems": 5,
    "includeRelated": True,
    "maxRelatedSecurities": 5,
    "maxConcurrency": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-finance-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ],
  "startUrls": [],
  "includeFinancials": true,
  "includeNews": true,
  "maxNewsItems": 5,
  "includeRelated": true,
  "maxRelatedSecurities": 5,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/google-finance-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/google-finance-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Finance Scraper",
        "description": "Extract Google Finance quotes, fundamentals, company profiles, quarterly and annual statements, related securities, and news. Export via API, JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "6KIHj3MOW6YgzMaog"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-finance-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-finance-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~google-finance-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-finance-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~google-finance-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-finance-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "symbols": {
                        "title": "📈 Tickers and exchanges",
                        "type": "array",
                        "description": "Add one TICKER:EXCHANGE pair per entry, for example AAPL:NASDAQ or BMW:ETR.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Google Finance quote URLs",
                        "type": "array",
                        "description": "Add canonical google.com/finance/quote/TICKER:EXCHANGE URLs. Other Google products and non-Google hosts are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeFinancials": {
                        "title": "Include financial statements",
                        "type": "boolean",
                        "description": "Extract up to eight quarterly and six annual revenue, net income, EPS, and margin records.",
                        "default": true
                    },
                    "includeNews": {
                        "title": "Include news",
                        "type": "boolean",
                        "description": "Include current Google Finance news headlines, publishers, relative publication times, and source URLs.",
                        "default": true
                    },
                    "maxNewsItems": {
                        "title": "Maximum news items per security",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Limit current news stories saved inside each security record.",
                        "default": 10
                    },
                    "includeRelated": {
                        "title": "Include related securities",
                        "type": "boolean",
                        "description": "Include Google Finance related tickers with company, price, and percentage change.",
                        "default": true
                    },
                    "maxRelatedSecurities": {
                        "title": "Maximum related securities",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Limit related-security records nested under each requested ticker.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Maximum parallel requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Control how many quote pages are requested at once. Keep this conservative for stable scheduled portfolio refreshes.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optionally route requests through Apify Proxy for geography or IP rotation. Direct HTTP is used when omitted.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```