# Finviz Scraper (`publicmoney/finviz-scraper`) Actor

Extract the Finviz fundamentals snapshot for any US ticker: 80-plus fields covering valuation, margins, growth, institutional and insider ownership, short interest, float and analyst target. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/finviz-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

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

Finviz packs the densest free fundamentals table on the web, more than 80 fields on one page, and charges for the API that would let you read it. This Actor reads the snapshot for any US-listed ticker and returns every field as a structured record: valuation, margins, growth, profitability, ownership, short interest and float, and the analyst target and recommendation. A second mode returns the news Finviz aggregates for the ticker.

### What it does

- Returns **more than 80 fields per ticker** in one record, which is the whole Finviz snapshot table rather than a selection of it.
- Gives the key ratios **twice**: as Finviz prints them (`marketCap` reads `3.85T`) and as numbers you can sort on (`marketCapNumeric` reads `3850000000000`).
- Carries **short interest and float** (`shortFloat`, `shortRatio`), which almost no free quote source publishes.
- Carries **institutional and insider ownership** with their transaction percentages, so you can see who is accumulating.
- Reports the **analyst price target and recommendation score** next to the current price.
- Reads through a US residential egress, because Finviz blocks datacenter traffic. It is handled for you and there is nothing to configure.
- Has a second mode for **news**, one record per story Finviz aggregates for the ticker.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Screen on short interest | Sort on `shortFloat` and `shortRatio` across a ticker list |
| Find what institutions are buying | Read `instOwn` next to `instTrans` |
| Compare a ticker against its target | Divide `targetPrice` by `value` |
| Build a valuation table | Use the `Numeric` fields so the sort is on numbers, not strings |
| Screen for margin quality | Read gross, operating and profit margin in the same record |
| Feed a finance agent | Call the Actor over MCP and let the model ask for the symbol it needs |

### Quick start

1. Click **Try for free**.
2. Add your tickers, one per line: `AAPL`, `MSFT`, `NVDA`. Finviz covers US-listed tickers.
3. Leave **Mode** on `snapshot`, or switch it to `news`.
4. Click **Start**. Rows appear within seconds.
5. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `tickers` | array | `AAPL` | US-listed tickers to read |
| `mode` | string | `snapshot` | `snapshot` returns the fundamentals table, `news` a record per story |
| `newsPerTicker` | integer | `20` | Stories per ticker in news mode |
| `maxItems` | integer | `0` | Caps how many tickers are read. `0` reads them all |

```json
{
    "tickers": [
        "AAPL",
        "MSFT",
        "NVDA"
    ],
    "mode": "snapshot",
    "maxItems": 0
}
```

### Output

One dataset item per ticker. Finviz prints a dash for a field it has no value for, and the Actor drops those rather than returning the dash, so a record carries what the ticker actually has.

| Field group | Fields |
| --- | --- |
| Identity | `status`, `tickerSymbol`, `company`, `sector`, `industry`, `country`, `url` |
| Price | `value`, `change`, `prevClose`, `volume`, `avgVolume`, `relVolume` |
| Valuation | `marketCap`, `marketCapNumeric`, `pE`, `pENumeric`, `forwardPE`, `pS`, `pB`, `peg` |
| Earnings | `epsTtm`, `epsTtmNumeric`, `epsNextY`, `epsGrowthThisY`, `epsGrowthNext5Y` |
| Margins | `grossMargin`, `operMargin`, `profitMargin`, `roa`, `roe`, `roi` |
| Ownership | `instOwn`, `instTrans`, `insiderOwn`, `insiderTrans` |
| Short interest | `shortFloat`, `shortRatio`, `shortInterest` |
| Analyst | `targetPrice`, `recommendation` |
| News mode | `headline`, `publisher`, `datePublished`, `url` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "tickerSymbol": "AAPL",
    "company": "Apple Inc.",
    "sector": "Technology",
    "industry": "Consumer Electronics",
    "country": "USA",
    "value": 319.97,
    "marketCap": "4.67T",
    "marketCapNumeric": 4670000000000,
    "pE": "36.65",
    "pENumeric": 36.65,
    "epsTtm": "8.73",
    "epsTtmNumeric": 8.73,
    "profitMargin": "26.30%",
    "roe": "151.31%",
    "instOwn": "62.40%",
    "insiderOwn": "0.06%",
    "shortFloat": "0.62%",
    "shortRatio": 1.18,
    "targetPrice": 352.18,
    "recommendation": 1.9,
    "validFrom": "2026-09-04T20:00:01.000Z",
    "url": "https://finviz.com/quote.ashx?t=AAPL"
}
```

#### What does news mode return?

`mode: "news"` returns the stories Finviz aggregates on the ticker page, which pulls from several publishers rather than one newsroom: `headline`, `publisher`, `datePublished` and `url`, plus the `tickerSymbol` the story was found under. News is charged as news items rather than as snapshot records.

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~finviz-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tickers": ["AAPL", "MSFT", "NVDA"], "mode": "snapshot", "maxItems": 0}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/finviz-scraper").call(run_input={"tickers": ["AAPL", "MSFT", "NVDA"], "mode": "snapshot", "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["value"], item["validFrom"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/finviz-scraper"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Record with data | $0.002 | $0.0007 |
| News article | $0.001 | $0.00035 |
| Actor start | $0.00005 per GB | Same |

A record that returned no data is published as a failure row and is **never charged**. Six volume tiers apply, so the per-record price falls with monthly volume.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| Every ticker returns `failed` | Finviz is blocking the egress this Actor uses. It is not settable from the input, so open an issue on the Issues tab and we will move it. |
| A non-US ticker fails | Finviz covers US listings. Use the FT Markets Actor in this fleet for international instruments. |
| A field is missing that Finviz shows as a dash | That dash means Finviz has no value. The Actor drops the field rather than returning a dash you would have to parse. |
| I want to sort and the value is a string | Use the `Numeric` twin of the field. `marketCap` is `3.85T` for display and `marketCapNumeric` is the number. |
| `recommendation` is a number, not a word | That is Finviz's own scale, where 1 is a strong buy and 5 a strong sell. |

### FAQ

#### Is there a free Finviz API?

No. Finviz sells an API and export as part of Finviz Elite, and there is no free tier. This Actor reads the public snapshot page instead and is charged per record.

#### Can I use this as a stock screener API?

It reads the fundamentals snapshot for tickers you name, so you screen by pulling your candidate list and filtering on the numeric fields yourself. It does not run Finviz's own screener query.

#### Why are there two versions of each ratio?

Finviz prints values for humans, so market cap reads `3.85T`. Every key field also comes back with a `Numeric` twin holding the plain number, so you can sort and compute without parsing.

#### Does it return historical prices?

No. Each record is the current snapshot as the source publishes it. To build a series, schedule the Actor and let the dataset accumulate a row per input per run. Each row carries `validFrom`, so the series is correctly timestamped.

#### Which tickers are covered?

US listings. Finviz does not cover international instruments, and for those the FT Markets Actor in this fleet is the one to use.

#### Do I need a Finviz API key?

No. You need an Apify token to call the Actor over the API. No Finviz credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

#### Is it legal to scrape Finviz?

This Actor reads public Finviz data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

### Changelog

- **0.0.2** Added news mode and the numeric twin for every key ratio.
- **0.0.1** First release. The full Finviz fundamentals snapshot per ticker.

### Feedback

Found a field Finviz publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

## `tickers` (type: `array`):

US-listed tickers to read, one per line. Finviz covers US listings only; for international instruments use the FT Markets Actor in this fleet. Examples: 'AAPL', 'MSFT', 'NVDA'. Default is 'AAPL'.

## `mode` (type: `string`):

What each record represents. Snapshot returns the full Finviz fundamentals table, more than 80 fields per ticker. News returns one record per story Finviz aggregates for the ticker, charged as news items. Examples: 'snapshot', 'news'. Default is 'snapshot'.

## `newsPerTicker` (type: `integer`):

How many stories to return per ticker in news mode, newest first. Finviz aggregates from several publishers rather than one newsroom. Ignored in snapshot mode. Examples: 5, 20, 50. Default is 20.

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

Maximum number of tickers to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every ticker given.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "mode": "snapshot",
  "newsPerTicker": 20,
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

One item per requested input, in the default dataset.

# 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 = {
    "tickers": [
        "AAPL",
        "MSFT"
    ],
    "mode": "snapshot",
    "newsPerTicker": 20,
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/finviz-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 = {
    "tickers": [
        "AAPL",
        "MSFT",
    ],
    "mode": "snapshot",
    "newsPerTicker": 20,
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/finviz-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 '{
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "mode": "snapshot",
  "newsPerTicker": 20,
  "maxItems": 0
}' |
apify call publicmoney/finviz-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicmoney/finviz-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/AqQBJOC3hKegp2KV3/builds/tnd2XephQ0BATxWNu/openapi.json