# Finviz Ticker Scraper (`rl1987/finviz-scraper`) Actor

Scrapes stock, ETF, index, forex, crypto, and futures detail pages from Finviz for a given list of tickers.

- **URL**: https://apify.com/rl1987/finviz-scraper.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 ticker scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

Scrapes detailed stock, ETF, index, forex, crypto, and futures data from **[Finviz](https://finviz.com/)** for any list of tickers you provide. Just give it tickers like `AAPL`, `SPY`, `EURUSD`, `BTCUSD`, or `ES` — no need to tell it what asset class each one is, the Actor figures that out automatically. Try it now, or run it via the [Apify API](https://docs.apify.com/api/v2), schedule it to run daily, or plug it into your own pipeline with [integrations](https://apify.com/integrations) for Zapier, Make, Google Sheets, and more.

### Why use the Finviz Ticker Scraper?

Finviz packs an unusual amount of fundamental, technical, and sentiment data onto a single ticker page — valuation ratios, ownership, insider trades, analyst ratings, and news — but there's no official API and copy-pasting doesn't scale. This Actor is built for:

- **Portfolio and watchlist monitoring** — pull fresh valuation and technical stats for a list of holdings on a schedule.
- **Screening and research pipelines** — feed structured fundamentals into your own models or spreadsheets instead of re-deriving them from scratch.
- **Cross-asset dashboards** — a single input list can mix stocks, ETFs, forex pairs, crypto pairs, and futures contracts.
- **Insider and institutional tracking** — insider trades and top institutional holders are extracted as structured records, not just table text.

### How to use the Finviz Ticker Scraper

1. Open the Actor's **Input** tab.
2. Add the tickers you want to scrape to the `tickers` field (e.g. `AAPL`, `MSFT`, `SPY`, `EURUSD`, `BTCUSD`, `ES`).
3. Optionally adjust `maxConcurrency` or the proxy settings.
4. Click **Start** and download the results from the **Output** tab once the run finishes.

### Input

| Field | Type | Description |
|---|---|---|
| `tickers` | array of strings | Required. Tickers to scrape. Any mix of stocks/ETFs/indices (`AAPL`, `SPY`), forex pairs (`EURUSD`), crypto pairs (`BTCUSD`), and futures contracts (`ES`, `CL`, `GC`, ...). |
| `maxConcurrency` | integer | Optional. Maximum number of ticker pages fetched in parallel. Default `10`. |
| `proxyConfiguration` | object | Optional. Proxy settings (Apify Proxy recommended) to avoid rate limiting. Default uses Apify Proxy. |

Example input:

```json
{
  "tickers": ["AAPL", "SPY", "EURUSD", "BTCUSD", "ES"],
  "maxConcurrency": 10,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### How asset class detection works

Each ticker is resolved in this order: **stock/ETF/index** (Finviz's main quote page, tried first since it covers the vast majority of tickers) → **crypto** → **forex** → **futures**. If a ticker exists in more than one asset class under the same symbol (rare, e.g. `ES` is both a real NYSE stock, Eversource Energy, and the S\&P 500 futures code), the stock match wins. A ticker that isn't found in any asset class is still included in the output dataset with an `error` field instead of being silently dropped.

### Output

Output shape depends on asset class. A stock/ETF item looks like:

```json
{
  "ticker": "AAPL",
  "assetType": "stock",
  "url": "https://finviz.com/stock?t=AAPL",
  "companyName": "Apple Inc",
  "exchange": "NASD",
  "sector": "Technology",
  "industry": "Consumer Electronics",
  "country": "USA",
  "marketCapGroup": "Mega",
  "price": "342.71",
  "priceChange": "+2.63",
  "priceChangePercent": "0.77",
  "description": "Apple, Inc. engages in the design, manufacture, and sale of smartphones...",
  "stats": { "P/E": "41.46", "Market Cap": "5033.50B", "RSI (14)": "70.21", "...": "... ~80 fields total" },
  "analystRatings": [{ "Date": "Jul-24-26", "Action": "Reiterated", "Analyst": "Robert W. Baird", "Rating Change": "Outperform", "Price Target Change": "$310 → $330" }],
  "insiderTrading": [{ "name": "Borders Ben", "transactionType": "Sale", "...": "..." }],
  "institutionalOwnership": { "managers": [{ "name": "BlackRock, Inc.", "percOwnership": 7.8 }], "funds": ["..."] },
  "peers": ["MSFT", "GOOG", "META"],
  "news": [{ "date": "Today", "time": "09:28AM", "title": "...", "url": "...", "source": "Barrons.com" }],
  "financials": { "annual": { "gaapEps": ["..."], "sales": ["..."] }, "quarterly": { "...": "..." } }
}
```

A forex/crypto/futures item is lighter (Finviz only exposes quote + chart data for these, not fundamentals):

```json
{
  "ticker": "EURUSD",
  "assetType": "forex",
  "label": "EUR/USD",
  "last": 1.1389,
  "change": 0.03,
  "changeUsd": 0.0003,
  "prevClose": 1.13861,
  "high": 1.14036,
  "low": 1.13745,
  "sparkline": [1.137, 1.1417, "..."]
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the **Output** tab or via the API.

#### Main data fields

| Field | Description |
|---|---|
| `ticker` / `assetType` | The requested ticker and its detected asset class (`stock`, `etf`, `forex`, `crypto`, `futures`, or `null` if not found). |
| `stats` | Stock/ETF only. The full ~80-field snapshot table (valuation, profitability, ownership, technicals). |
| `analystRatings` | Stock/ETF only. Recent analyst rating and price target changes. |
| `insiderTrading` | Stock/ETF only. Recent insider buy/sell transactions. |
| `institutionalOwnership` | Stock/ETF only. Top institutional managers and funds holding the stock. |
| `news` | Stock/ETF only. Recent headlines with source and link. |
| `last` / `sparkline` | Forex/crypto/futures only. Latest quote and recent daily-chart price series. |

### Cost of scraping Finviz data

This Actor uses fast HTTP requests (no browser) for every page, so it's cheap to run: a typical stock/ETF ticker costs one request, and every forex/crypto/futures ticker in a run shares just three "listing" requests in total. Expect on the order of a few hundred tickers per Compute Unit, depending on your Apify plan and proxy usage.

### Tips

- Group runs by ticker list rather than scheduling one ticker per run — the shared forex/crypto/futures listing lookups are only fetched once per run.
- Keep `maxConcurrency` moderate (its default of 10 is a good starting point) and leave Apify Proxy enabled to avoid rate limiting on large ticker lists.
- Full income statement / balance sheet / cash flow tables are a Finviz Elite (paid) feature loaded dynamically and are **not** included; the `financials` field covers the free mini EPS/Sales/Shares-Outstanding series only.

### FAQ

**Is this legal?** This Actor only extracts already-public data from pages you can view in a regular browser. You are responsible for complying with Finviz's [Terms of Service](https://finviz.com/help/terms-conditions.ashx) and applicable law in your jurisdiction.

**A ticker returned `"error": "Ticker not found..."` — why?** Finviz free tier only covers stocks/ETFs listed on NYSE, NASDAQ, and AMEX (no international or OTC/PK stocks), plus a limited set of major forex pairs, crypto pairs, and futures contracts. If your ticker isn't covered by Finviz itself, this Actor can't retrieve it either.

**Found a bug or missing field?** Open an issue on the Actor's Issues tab, or reach out — custom scraping solutions are also available.

# Actor input Schema

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

List of tickers to scrape from Finviz. Supports stocks, ETFs, indices (e.g. AAPL, SPY), forex pairs (e.g. EURUSD), crypto pairs (e.g. BTCUSD), and futures contracts (e.g. ES, CL, GC). The asset class is auto-detected per ticker.

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

Maximum number of ticker pages fetched in parallel.

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

Proxy servers used to fetch Finviz pages. Finviz blocks Apify's datacenter IPs (403), so Residential proxy is used by default.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "SPY",
    "EURUSD",
    "BTCUSD",
    "ES"
  ],
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset with one item per ticker requested in the input.

# 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",
        "SPY",
        "EURUSD",
        "BTCUSD",
        "ES"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/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",
        "SPY",
        "EURUSD",
        "BTCUSD",
        "ES",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/finviz-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 '{
  "tickers": [
    "AAPL",
    "SPY",
    "EURUSD",
    "BTCUSD",
    "ES"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call rl1987/finviz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/3JEksvMCvJLqjOPdr/builds/jnKx40hQR8BfEKdq7/openapi.json