# Stock, Options & Crypto Screener - Dividend & DeFi Yield Data (`rolescout/tradescout-stock-crypto-screener`) Actor

Stock options screener (RSI, ATR%, relative volume, VWAP distance, ATM IV), crypto screener with a Fear & Greed overlay, municipal income funds with tax-equivalent yields and dividend streaks, and crypto staking and stablecoin yields with APY and TVL. Ranked rows as JSON/CSV. Not investment advice

- **URL**: https://apify.com/rolescout/tradescout-stock-crypto-screener.md
- **Developed by:** [Dave Fergins](https://apify.com/rolescout) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 board fetcheds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Stock, options and crypto screener data as plain JSON or CSV rows from one run. Four ranked boards: a stock options screener listing short-dated US equity options candidates scored on RSI, ATR%, relative volume, VWAP distance, momentum and at-the-money implied volatility; a crypto screener with a market-wide Fear & Greed overlay; federally tax-exempt municipal income funds with yield, tax-equivalent yield at the 24%, 32% and 37% federal brackets, dividend CAGR and streak years; and crypto staking and stablecoin yields with APY, TVL and a letter grade. Every row is impersonal screening data with the provider's disclaimer and position disclosure attached. It is not investment advice and it carries no buy or sell instruction.

The Actor is a thin client: it fetches each board you select from the data provider, keeps the top rows, drops anything that could read as a trade instruction, and writes the rest to the dataset. A run takes seconds and uses 256 MB. You need no API key, data subscription or brokerage login; the Actor carries its own provider credential and you only tick the sanctions attestation.

### Stock options screener: RSI, ATR%, relative volume, VWAP distance and ATM IV per row

The options board ranks US equities that currently show a short-dated options setup. Each row carries `symbol`, a letter `grade`, a composite `score`, `signal_strength`, how many `confluence_count` and `caution_count` the scan found, a `macro_factor`, a `news_sentiment` score and an `excluded` flag. The `observed` object holds the readings behind the rank: `last`, `rsi`, `atr_pct`, `rel_vol`, `vwap_dist_pct`, `mom_30m_pct`, `atm_iv`, `day_change_pct`, `daily_trend`, `momentum_dir`, `event_risk` and `session_phase`. An `illustrative_contract` object shows one contract that fits the setup - `expiry`, `dte`, `delta`, `bid`, `ask`, `spread_pct`, `volume`, `open_interest` - as an illustration of the setup's shape, not something to trade. Set `includeHeadlines` to add the `headlines` the scan read.

### Crypto screener with a Fear & Greed overlay

The crypto board applies the same technical screen to spot pairs, 24/7, with the market-wide Fear & Greed reading folded into `macro_factor`. Rows carry the same `symbol`, `grade`, `score`, `signal_strength`, confluence and caution counts, `news_sentiment` and `observed` readings as the options board, without the contract object. This board is the largest - several hundred pairs - so `maxRowsPerBoard` is the knob that keeps the dataset to the top of the ranking.

### Municipal income funds: tax-equivalent yield, dividend CAGR and streak years

The dividends board ranks federally tax-exempt municipal income funds, so it is dividend income data for municipal bond funds rather than a dividend stock list. Each row carries `symbol`, the `fund` name, a letter `grade` and numeric `rating`, `yield_pct`, `price`, `ttm_dividend`, tax-equivalent yields for the 24%, 32% and 37% federal brackets (`tax_equiv_yield_24pct_bracket` and so on), `payments_per_year`, `growth_streak_years`, `no_cut_years`, `last_cut_year`, `dividend_cagr_5y_pct` and a `notes` list.

### DeFi yield scanner: crypto staking and stablecoin yields with APY and TVL

The yields board serves three lists flattened into rows and tagged by `kind`: `staking` and `stablecoin` pools with `symbol`, `project`, `chain`, `apy`, `apy_base` (the base yield before token emissions), `tvl_usd`, a letter `rating` and a `score`; and `cefi` offers with `platform`, `asset`, `apy` and a `note`. `minGrade` reads the letter `rating` on this board.

### Example input

```json
{
    "boards": ["picks", "dividends", "crypto", "yields"],
    "maxRowsPerBoard": 50,
    "minGrade": "any",
    "attestNotSanctioned": true,
    "includeHeadlines": false
}
```

`boards` uses the provider's route names exactly as shown; the first one is the options board. `maxRowsPerBoard` keeps the top N of each ranked board, 0 keeps everything. `minGrade` keeps rows graded at least that well (rows with no letter are kept). `attestNotSanctioned` must be true or the run stops before fetching anything.

### Output: example rows, CSV views and the OUTPUT record

Every row starts with the same six columns - `board`, `as_of`, `board_hash`, `publication`, `disclaimer`, `operator_position_disclosure` - then the board's own fields unchanged. Rows are written in the board's rank order. A dividends row looks like this:

```json
{
    "board": "dividends",
    "as_of": "2026-10-13T18:07:17Z",
    "board_hash": "320f62c94b67f629926e5c840a053bef",
    "publication": "scalpstream-dividends",
    "disclaimer": "This is an impersonal, general-circulation research feed ...",
    "operator_position_disclosure": "The operator actively trades securities named in this feed ...",
    "symbol": "NXP",
    "fund": "Nuveen Select Tax-Free Income CEF - unleveraged",
    "grade": "A",
    "yield_pct": 4.93,
    "tax_equiv_yield_24pct_bracket": 6.49,
    "tax_equiv_yield_32pct_bracket": 7.25,
    "tax_equiv_yield_37pct_bracket": 7.83,
    "payments_per_year": 12,
    "growth_streak_years": 3,
    "no_cut_years": 9
}
```

An options row carries the nested objects intact:

```json
{
    "board": "picks",
    "as_of": "2026-10-13T18:07:17Z",
    "symbol": "XYZ",
    "grade": "B",
    "score": 71.4,
    "signal_strength": 2,
    "confluence_count": 3,
    "caution_count": 1,
    "news_sentiment": 0.2,
    "observed": { "last": 42.17, "rsi": 58.3, "atr_pct": 2.9, "rel_vol": 1.8, "vwap_dist_pct": 0.6, "atm_iv": 0.41, "day_change_pct": 1.7, "daily_trend": "up" },
    "illustrative_contract": { "expiry": "2026-10-17", "dte": 4, "delta": 0.46, "bid": 1.05, "ask": 1.15, "spread_pct": 9.1, "volume": 812, "open_interest": 2410 }
}
```

Fields named `verdict`, `plan`, `size`, `sizing` or `stake` are removed from every row at every nesting level, whatever the provider sends. The dataset has one table view per board (options, dividends, crypto, yields) choosing that board's columns; filter on `board` when you export more than one board as CSV. The run's `OUTPUT` key-value record holds each board's response verbatim, keyed by board name, plus an `errors` map for any board that failed.

### Pricing: one board-fetched event per board

One `board-fetched` event per board the provider served, whatever the number of rows: all four boards is four events, one board is one event. Rows are never billed individually, so `maxRowsPerBoard` changes the size of the dataset, not the price. A daily schedule of all four boards is therefore 30 runs and 120 events a month; a daily run of the crypto board alone is 30 events. A board that fails (provider unavailable, token rejected) is not charged, and the run still succeeds with the boards that worked; only a run where every selected board failed ends as failed. The per-event price is on this page's Pricing tab and steps down with your Apify plan; at any tier, all four boards once a day is 120 events a month.

### Use cases: stock screener API, scheduled market data to Google Sheets or CSV

- Stock screener API: schedule the run and read the dataset as JSON through the Apify API, with `as_of` and `board_hash` on every row so a fresh board is distinguishable from a repeat.
- Options screener data as JSON: one row per candidate with `observed` readings and an `illustrative_contract` carrying delta, bid, ask, spread and open interest, ready for a notebook or a spreadsheet.
- Crypto screener JSON or CSV with the Fear & Greed overlay, trimmed to the top of the ranking by `maxRowsPerBoard`.
- Dividend income data for municipal bond funds: yield and tax-equivalent yield at the 24%, 32% and 37% brackets, dividend CAGR and streak years, for a tax-aware income spreadsheet.
- DeFi yield scanner rows: crypto staking and stablecoin APY with base APY, TVL and a grade, plus CeFi offers, in one flat table.
- Scheduled market data to Google Sheets or CSV: use the dataset's CSV export or Apify's Google Sheets integration on each run, and filter on `board` when more than one board is in the dataset.
- AI agents and automations: like any public Actor it can be called through the Apify API, a webhook or Apify's MCP server, and every row it hands back still carries the disclaimer and the operator position disclosure.

### Not investment advice

Every row carries the provider's disclaimer and operator position disclosure verbatim, so they travel with the data into any CSV or spreadsheet. They read:

> This is an impersonal, general-circulation research feed for educational and informational purposes only. It is the same for every recipient and is not tailored to anyone's financial situation. It is NOT investment advice and NOT a recommendation to buy or sell any security or option. Options trading involves substantial risk of loss. Do your own research and consult a licensed professional before trading.
>
> The operator actively trades securities named in this feed and may transact (including before, after, or contrary to any signal shown) at any time and without notice. Assume the operator holds a position in any name shown.

No row carries an entry, stop, target, direction, position size or verdict. Any contract shown is illustrative of the setup, not an instruction to trade it.

### Sanctions attestation

The data provider requires an attestation from the party receiving the data that it is not a sanctioned party. The `attestNotSanctioned` checkbox is that attestation: it is yours, not the Actor's, and it is forwarded to the provider with each request as a compliance header. Leave it unticked and the run stops with a status message before any request is made; nothing is fetched and nothing is charged.

### FAQ

**Is this a stock screener API I can run on a schedule?** Yes. Run it on a schedule or through the Apify API and read the dataset as JSON or CSV; each run writes the boards as they stand at that moment, with `as_of` and `board_hash` on every row so you can tell a fresh board from a repeat.

**Does it give buy or sell signals?** No. The rows are ranked screening data - readings, grades and scores - with the provider's disclaimer on every one. There is no verdict, plan, direction or size, and anything shaped like one is stripped before the row is written.

**Do I need an API key, a data subscription or a brokerage account?** No. The Actor carries its own provider credential. The only thing you supply is the sanctions attestation in the input.

**Can I get options screener data with delta, bid, ask, spread and open interest as JSON?** Yes. Each options row carries one `illustrative_contract` with `expiry`, `dte`, `delta`, `bid`, `ask`, `spread_pct`, `volume` and `open_interest`, next to the `observed` readings. It is one contract that fits the setup's shape, not a full chain and not an instruction.

**How do I get the crypto screener into Google Sheets or a CSV file?** Open the run's dataset and export the `crypto` view as CSV, or attach Apify's Google Sheets integration to the Actor so every scheduled run appends its rows. Filter on `board` if you fetched more than one board.

**What is tax-equivalent yield and which brackets are included?** It is the taxable yield that would leave the same after-tax income as the fund's federally tax-exempt yield. Each dividends row carries it for the 24%, 32% and 37% federal brackets, next to the plain `yield_pct`.

**Which crypto yields are included and what does apy_base mean?** Staking and stablecoin pools with `project`, `chain`, `apy`, `tvl_usd`, a letter `rating` and a `score`, plus CeFi offers by `platform`. `apy_base` is the pool's base yield before token emissions, so `apy` minus `apy_base` is the part paid in incentives.

**How fresh is the data?** Each board carries the provider's `as_of` scan time and a `board_hash`. Two runs with the same hash fetched the same board; the data is a periodic scan, not a live tick stream.

**Why did a board fail while the others worked?** The provider answers each board on its own; a board that is being rescanned answers with an error, which the run records in the status message and the `OUTPUT` record's `errors` map and skips without charging. Run again a few minutes later.

**What does `minGrade` do on the yields board?** Yield rows carry their letter as `rating`, so `minGrade` reads that; the dividends board's numeric `rating` is ignored and its letter `grade` is used.

**Can I get only one board?** Select one board in `boards`. One board is one event.

# Actor input Schema

## `boards` (type: `array`):

Which ranked screening boards to fetch: the stock options screener, the municipal income fund (dividend) board, the crypto screener and the crypto yields board. Leave all four selected for the full set; each board is one billable event.

## `maxRowsPerBoard` (type: `integer`):

Boards are ranked, so this keeps the top N of each. 0 means every row the board serves (the crypto screener can run to several hundred pairs). It changes the dataset size, not the price.

## `minGrade` (type: `string`):

Keep only rows graded at least this well. Rows without a letter grade are kept whatever you choose.

## `attestNotSanctioned` (type: `boolean`):

Required. The run refuses to fetch anything until this is ticked. Your attestation is forwarded to the data provider with the request, as the provider requires it from the party receiving the data.

## `includeHeadlines` (type: `boolean`):

Add the news headlines each options and crypto row was scored against (the news_sentiment inputs). Off by default to keep rows small.

## Actor input object example

```json
{
  "boards": [
    "picks",
    "dividends",
    "crypto",
    "yields"
  ],
  "maxRowsPerBoard": 50,
  "minGrade": "any",
  "attestNotSanctioned": true,
  "includeHeadlines": false
}
```

# Actor output Schema

## `rows` (type: `string`):

Every row from every fetched board, with the board's own fields intact including nested objects.

## `options` (type: `string`):

Columns for the options board. Filter on board = picks when more than one board was fetched.

## `dividends` (type: `string`):

Columns for the municipal income board. Filter on board = dividends when more than one board was fetched.

## `crypto` (type: `string`):

Columns for the crypto board. Filter on board = crypto when more than one board was fetched.

## `yields` (type: `string`):

Columns for the staking, stablecoin and CeFi yield rows. Filter on board = yields when more than one board was fetched.

## `envelopes` (type: `string`):

The feed's response for each board verbatim, keyed by board name, plus an errors map for any board that failed.

# 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 = {
    "boards": [
        "picks",
        "dividends",
        "crypto",
        "yields"
    ],
    "attestNotSanctioned": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("rolescout/tradescout-stock-crypto-screener").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 = {
    "boards": [
        "picks",
        "dividends",
        "crypto",
        "yields",
    ],
    "attestNotSanctioned": True,
}

# Run the Actor and wait for it to finish
run = client.actor("rolescout/tradescout-stock-crypto-screener").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 '{
  "boards": [
    "picks",
    "dividends",
    "crypto",
    "yields"
  ],
  "attestNotSanctioned": true
}' |
apify call rolescout/tradescout-stock-crypto-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rolescout/tradescout-stock-crypto-screener"
        }
    }
}
```

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/MaKrAwyiyZutwJC7P/builds/ZpLmEEdaTXwz0gIAi/openapi.json