# 🎯 Analyst Price Targets — Consensus, Upgrades, Downgrades (`nexgendata/analyst-price-targets`) Actor

Track sell-side analyst price targets, consensus ratings, recent upgrades/downgrades across US-listed stocks. Bloomberg-style ratings distribution with upside/downside vs current price. Pay-per-result for portfolio managers, retail smart-money followers, IR teams tracking street sentiment.

- **URL**: https://apify.com/nexgendata/analyst-price-targets.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 analyst target records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Analyst Price Targets — Consensus, Upgrades & Downgrades

Track sell-side analyst price targets, consensus ratings, recent upgrades and downgrades across every US-listed stock. One pay-per-result API call returns the Bloomberg-style consensus snapshot you need to run a portfolio: mean / high / low / median price target, the analyst-count behind it, the buy / hold / sell distribution, and the firm-by-firm trail of recent rating actions from the past 90 days.

### 📊 Sample Output

[![🎯 Analyst Price Targets — Consensus, Upgrades, Downgrades sample output — 🎯 Analyst Price Targets — Consensus, Upgrades, Downgrades, premium API, JSON output, NexGenData premium dataset for analysts, ](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/analyst-price-targets-output.png)](https://apify.com/nexgendata/analyst-price-targets)

Built for portfolio managers running long/short books, retail "smart money" followers who track street consensus, and IR teams that need to know what the sell-side is actually saying about their tape before earnings, conferences, or roadshows.

### What you get per record

Every record is one US-listed ticker, normalized into a clean, ready-to-merge schema. Hit it with one symbol or fan it across the S&P 500.

| Field | Description |
|---|---|
| `symbol` | Ticker (uppercase). |
| `company_name` | Yahoo Finance long name. |
| `sector` / `industry` | GICS-style sector + finer industry classification. |
| `current_price` | Latest regular-session price (USD). |
| `consensus_target_price` | Mean of all contributing sell-side 12-month price targets. |
| `target_median` | Median of contributing targets — outlier-resistant alternative to mean. |
| `target_high` / `target_low` | High and low of the contributing target range. Useful for sizing dispersion. |
| `n_analysts` | Number of analysts contributing to the consensus mean. |
| `upside_pct` | `(consensus_target - current_price) / current_price * 100`. Positive = upside. |
| `recommendation_mean` | Yahoo's 1.0–5.0 sell-side mean (1.0 = Strong Buy, 5.0 = Sell). |
| `consensus_rating` | Bucketed rating: `Strong Buy` / `Buy` / `Hold` / `Sell` / `Strong Sell`. |
| `rating_strong_buy_count` | Count of Strong Buy ratings (current month). |
| `rating_buy_count` | Strong Buy + Buy ratings combined. |
| `rating_hold_count` | Count of Hold ratings. |
| `rating_sell_count` | Sell + Strong Sell ratings combined. |
| `rating_strong_sell_count` | Count of Strong Sell ratings. |
| `total_rated_analysts` | Sum of all five rating buckets. |
| `recent_actions` | Up to 20 firm-level actions from the last 90 days, formatted as plain-English lines (`"Morgan Stanley upgraded to Overweight from Equal-Weight, target raised to $250.00 (was $230.00) on 2026-05-08"`). |
| `n_recent_actions_90d` | Count of analyst actions in the trailing 90 days. |
| `last_action_date` | Most recent rating or target change date (ISO yyyy-mm-dd). |
| `market_cap_usd` | Latest market capitalization (USD). |
| `yahoo_url` | Convenience deep-link to Yahoo's analyst page. |
| `stockanalysis_url` | Convenience deep-link to Stockanalysis.com's forecast page. |
| `data_source` | Provenance: `yahoo_finance_quote_summary`. |
| `fetched_at_utc` | ISO timestamp of the fetch. |

### Why this actor exists

Sell-side price targets and consensus ratings are the most-quoted, least-accessible number in equities. Bloomberg, FactSet, and Refinitiv ship clean consensus feeds — at $24K, $18K, and $24K per terminal per year respectively. TipRanks and Zacks ship retail-grade views with anti-bot defenses and watered-down API access. For everyone in between — a fund manager spinning up a quant overlay, a retail aggregator running street-consensus screens, an IR team running a quarterly tape-check — there is no clean, pay-per-call option.

This actor fixes that:

- **Pay only for what you use.** $0.10 per symbol record. A 500-name S&P 500 sweep costs $50.01 and returns in under a minute. Compare that to a Bloomberg seat.
- **Bloomberg-style schema.** Mean / high / low / median target, ratings distribution, recent firm actions — the exact fields a PM wants on their morning sheet.
- **No anti-bot wrestling.** We handle Yahoo Finance's crumb/cookie dance for you, refresh tokens transparently on 401s, and ship clean JSON.
- **Pinned builds.** `?build=0.0.1` keeps your prod integrations stable; we never silently swap parsing logic underneath you.

### Comparison vs incumbents

| Capability | Bloomberg | FactSet | Refinitiv | TipRanks | Zacks | **Analyst Price Targets** |
|---|---|---|---|---|---|---|
| Annual minimum cost | $24,000+ | $18,000+ | $24,000+ | $1,000+ | $250+ | **$0 (pay-per-call)** |
| Per-symbol marginal cost | n/a | n/a | n/a | n/a | n/a | **$0.10** |
| Consensus mean target | Yes | Yes | Yes | Yes | Yes | **Yes** |
| Target high / low / median | Yes | Yes | Yes | Partial | Partial | **Yes** |
| Ratings distribution (SB/B/H/S/SS) | Yes | Yes | Yes | Yes | Partial | **Yes** |
| Firm-by-firm recent actions | Yes | Yes | Yes | Yes | Partial | **Yes (last 90d)** |
| 1.0–5.0 numeric consensus | Yes | Yes | Yes | No | Partial | **Yes** |
| Programmatic API access | Yes (enterprise) | Yes (enterprise) | Yes (enterprise) | Limited | Limited | **Yes (HTTP)** |
| No-contract, no-seat licensing | No | No | No | No | No | **Yes** |
| Cross-language clients | Yes | Yes | Yes | Limited | No | **Yes (Apify SDKs)** |
| Build-pinned stability | Yes | Yes | Yes | No | No | **Yes (`?build=`)** |
| Time to first record | Weeks (procurement) | Weeks | Weeks | Days | Days | **Minutes** |

### How to call it

#### Apify Console (browser UI)
Open the actor, paste symbols into the *Stock symbols* field, hit **Start**. Dataset appears in a table view in seconds.

#### Apify API (curl)
```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nexgendata~analyst-price-targets/runs?token=YOUR_TOKEN&build=0.0.1" \
  -H "Content-Type: application/json" \
  -d '{
    "symbols": ["AAPL", "NVDA", "TSLA", "MSFT", "AMZN"],
    "include_recent_actions": true,
    "min_n_analysts": 5
  }'
````

The `?build=0.0.1` pin is recommended for production integrations. Without it you ride latest, which can change without notice.

#### Apify Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("nexgendata/analyst-price-targets").call(
    run_input={
        "symbols": ["AAPL", "NVDA", "TSLA", "MSFT", "AMZN"],
        "min_upside_pct": 20,         ## only names with 20%+ upside
        "consensus_rating": "Buy",     ## only Buy-rated names
        "include_recent_actions": True,
    },
    build="0.0.1",
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["symbol"], item["consensus_target_price"], item["upside_pct"])
```

#### Apify JS SDK

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('nexgendata/analyst-price-targets').call({
    symbols: ['AAPL', 'NVDA', 'TSLA', 'MSFT', 'AMZN'],
    min_upside_pct: 20,
    include_recent_actions: true,
}, { build: '0.0.1' });

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `symbols` | array | `["AAPL","NVDA","TSLA","MSFT","AMZN"]` | US-listed tickers to fetch. Case-insensitive. Required. |
| `limit` | int | `0` (all) | Max records to return after filters. `0` returns everything. |
| `min_upside_pct` | number | `-1000` (off) | Minimum upside vs current price. `20` for high-conviction longs. |
| `consensus_rating` | enum | `"all"` | Filter to one rating bucket: `Strong Buy`, `Buy`, `Hold`, `Sell`, `Strong Sell`. |
| `include_recent_actions` | bool | `true` | Populate `recent_actions` with last-90-day firm actions. |
| `min_n_analysts` | int | `0` (off) | Drop names with fewer than N contributing analysts. Use `15` for widely-covered names only. |

### Common workflows

#### Morning sheet — high-upside Buy-rated names

```json
{
  "symbols": ["AAPL","MSFT","NVDA","GOOGL","META","AMZN","TSLA","AVGO","ORCL","CRM"],
  "min_upside_pct": 15,
  "consensus_rating": "Buy",
  "min_n_analysts": 10
}
```

Filters to widely-covered names with at least 15% implied upside and a sell-side Buy consensus. Drop the result into your morning meeting deck.

#### Short candidate screen — Sell-rated names with downside

```json
{
  "symbols": ["...your watchlist..."],
  "min_upside_pct": -1000,
  "consensus_rating": "Sell"
}
```

Pair with `nexgendata/short-interest-tracker` to find names where the street and the borrow desk both flag downside.

#### IR street-check — what is being said about us

```json
{
  "symbols": ["TICKR"],
  "include_recent_actions": true
}
```

One call before earnings to summarize every analyst action in the last 90 days — target moves, rating changes, initiations, dropped coverage. Drop straight into the prep memo.

#### Smart-money following — newly upgraded names

Run with `include_recent_actions: true`, then filter results client-side for `n_recent_actions_90d > 3` and parse `recent_actions` for the string "upgraded". Daily delta detection for newsletter writers.

### Data sources & methodology

Primary source is Yahoo Finance's official `quoteSummary` endpoint, the same endpoint that powers `finance.yahoo.com/quote/{SYMBOL}/analysis`. We request six modules in a single call: `financialData`, `recommendationTrend`, `upgradeDowngradeHistory`, `price`, `summaryDetail`, and `assetProfile`. Yahoo's own consensus aggregation is itself sourced from sell-side feeds (Thomson Reuters / Refinitiv), so the targets and ratings here trace back to the same primary research desks that populate Bloomberg's consensus screen — just routed through Yahoo's free consumer endpoint.

Yahoo's crumb/cookie authentication is handled transparently. We boot consent cookies from `fc.yahoo.com`, exchange them for a crumb at `query2.finance.yahoo.com/v1/test/getcrumb`, and reuse the crumb across the run. Crumb expiry mid-run is detected and refreshed on the fly.

Concurrency is capped at 5 in-flight requests to stay below Yahoo's per-IP soft limit. A 500-symbol sweep typically completes in 50–90 seconds.

### Pricing

| Event | Charge |
|---|---|
| Actor start | $0.01 |
| Per analyst-target record | $0.10 |

A 5-symbol smoke run costs **$0.51**. A full S\&P 500 sweep costs **$50.01**. A Russell 1000 sweep costs **$100.01**.

There is no monthly minimum, no seat license, and no contract — you pay the Apify platform fee plus the per-event charges only on runs you actually execute. The 20% Apify margin is included in the prices above; we do not mark up beyond that.

### Sister actors in the NexGenData fleet

Layer this actor with the rest of the fleet for a full equity-research stack:

- [**`nexgendata/finviz-stock-screener`**](https://apify.com/nexgendata/finviz-stock-screener) — Finviz's full screener universe with 70+ filters. Feed its symbol list into this actor to bulk-pull consensus targets for any screen.
- [**`nexgendata/earnings-calendar`**](https://apify.com/nexgendata/earnings-calendar) — Upcoming earnings releases with EPS estimates, fiscal period, prior-period surprises. Run this actor against the upcoming-reporters list to find names where street sentiment has shifted into the print.
- [**`nexgendata/short-interest-tracker`**](https://apify.com/nexgendata/short-interest-tracker) — Bi-monthly short-interest reports, days-to-cover, % of float short. Cross-reference Sell-rated names here with high short-interest tickers there to find consensus-confirmed shorts.
- [**`nexgendata/sec-form4-insider-tracker`**](https://apify.com/nexgendata/sec-form4-insider-tracker) — Real-time insider buys and sells from SEC Form 4 filings. Stack with this actor to find names where the street and management agree on direction.
- [**`nexgendata/etf-holdings-tracker`**](https://apify.com/nexgendata/etf-holdings-tracker) — Daily ETF basket exposure. Useful for tracking which thematic ETFs hold the analyst-favorite names you surface here.
- [**`nexgendata/finance-mcp-server`**](https://apify.com/nexgendata/finance-mcp-server) — Anthropic MCP server bundling the entire NexGenData equity stack into one tool surface for Claude / GPT / agentic workflows. Drop it in and let the model pull consensus targets, screens, earnings, short interest, insider activity, and ETF holdings on demand.

### FAQ

**Why Yahoo Finance and not Stockanalysis.com / TipRanks / MarketBeat?**
We tested all five. Stockanalysis.com forecast pages SSR through Svelte and hydrate from a private API that returns 404 to non-browser callers. TipRanks blocks anonymous JSON. MarketBeat returns HTML with anti-bot challenges. Zacks is rate-limited and protected by Cloudflare. Yahoo's `quoteSummary` endpoint is the cleanest, most-reliable surface and is itself sourced from Refinitiv's institutional feed — so we get Bloomberg-quality consensus for free.

**How fresh is the consensus?**
Yahoo's financialData snapshot refreshes intra-day. Recommendation trend buckets refresh monthly. Upgrade/downgrade history rows appear within hours of the underlying note. For event-driven workflows we recommend rerunning the actor at the close each trading day.

**Can I scan the whole Russell 1000?**
Yes. Pass 1000 symbols, set `min_n_analysts: 5` to drop thinly-covered names, and the run completes in ~3 minutes for $100.01. We've stress-tested up to 2000 symbols per run without hitting Yahoo's edge limits.

**What if a symbol is an ADR / OTC / dual-listing?**
ADRs and major OTC names work. Pure foreign listings (e.g. ASML on AEX without an ADR) return null targets — Yahoo's analyst feed only covers the US-listed share class.

**Does it handle option-implied targets or buy-side targets?**
No. The output is pure sell-side. For option-implied moves see our forthcoming options-vol actor.

**Build pinning?**
Pin with `?build=0.0.1`. The build *number* (string), not the build *id*. Build numbers are stable; build ids rotate on every push. We bump 0.0.x for additive changes and 0.x.0 for any breaking schema change.

### Support & licensing

Private actor on the NexGenData Apify fleet. Access by request — contact via the Apify console or the affiliate signup below. Bulk-rate licensing, white-label deployments, and dedicated-instance options available on request.

**[Sign up via the NexGenData affiliate link](https://apify.com/nexgendata?fpr=2ayu9b)** — supports the fleet at no cost to you, gives you instant access to every NexGenData actor (10+ and growing) including this one, plus first-look at upcoming releases (consensus-EPS-revisions actor, options-vol actor, transcripts-sentiment actor). Affiliate signups stay on a flat 20% rev-share for the lifetime of the account.

Built and maintained by NexGenData. We focus on the equity-research stack the institutional vendors charge $20K+ for — and ship it pay-per-call.

# Actor input Schema

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

Array of US-listed stock tickers to fetch analyst price-target data for. Examples: \['AAPL', 'NVDA', 'TSLA', 'MSFT']. Tickers are case-insensitive — they are upper-cased before lookup. Supports common stock symbols on NYSE, NASDAQ, and major US exchanges. Each symbol returns one record with consensus target, high/low, ratings distribution, and recent analyst actions.

## `limit` (type: `integer`):

Maximum number of analyst price-target records to return after all filters apply. Set to 0 to return every input symbol that passes the filters. Useful for testing on small batches before running a full universe scan (S\&P 500, Russell 1000, custom watchlist).

## `min_upside_pct` (type: `number`):

Filter out names whose consensus target implies less than this percentage of upside vs current price. Use 20 for high-conviction longs, 50 for deep-value/distressed setups, or a negative number (e.g. -100) to include downside names too. Set to -1000 (default) to disable the filter and return everything. Computed as ((target - current) / current) \* 100.

## `consensus_rating` (type: `string`):

Filter records by sell-side consensus rating bucket. 'all' returns everything. Use 'Strong Buy' or 'Buy' to surface street-favorite names, 'Sell' or 'Strong Sell' to surface short candidates and value-trap warnings. The rating is derived from Yahoo Finance's recommendationKey field (1.0–5.0 mean scale).

## `include_recent_actions` (type: `boolean`):

If true, populates the 'recent\_actions' field with up to 20 individual sell-side actions from the last 90 days: firm name, rating change, target change, action type (Upgrade/Downgrade/Maintain/Initiate), and date. Disable for lighter payloads if you only need the consensus snapshot.

## `min_n_analysts` (type: `integer`):

Drop records where fewer than this many analysts contribute to the consensus target. Use 5 to filter out thinly-covered micro-caps where one outlier dominates the mean. Use 15 to filter to widely-covered names with statistically meaningful consensus. Set to 0 (default) to disable the filter.

## Actor input object example

```json
{
  "symbols": [
    "AAPL",
    "NVDA",
    "TSLA",
    "MSFT",
    "AMZN"
  ],
  "limit": 0,
  "min_upside_pct": -1000,
  "consensus_rating": "all",
  "include_recent_actions": true,
  "min_n_analysts": 0
}
```

# 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",
        "NVDA",
        "TSLA",
        "MSFT",
        "AMZN"
    ],
    "limit": 0,
    "min_upside_pct": -1000,
    "consensus_rating": "all",
    "include_recent_actions": true,
    "min_n_analysts": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/analyst-price-targets").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",
        "NVDA",
        "TSLA",
        "MSFT",
        "AMZN",
    ],
    "limit": 0,
    "min_upside_pct": -1000,
    "consensus_rating": "all",
    "include_recent_actions": True,
    "min_n_analysts": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/analyst-price-targets").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",
    "NVDA",
    "TSLA",
    "MSFT",
    "AMZN"
  ],
  "limit": 0,
  "min_upside_pct": -1000,
  "consensus_rating": "all",
  "include_recent_actions": true,
  "min_n_analysts": 0
}' |
apify call nexgendata/analyst-price-targets --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🎯 Analyst Price Targets — Consensus, Upgrades, Downgrades",
        "description": "Track sell-side analyst price targets, consensus ratings, recent upgrades/downgrades across US-listed stocks. Bloomberg-style ratings distribution with upside/downside vs current price. Pay-per-result for portfolio managers, retail smart-money followers, IR teams tracking street sentiment.",
        "version": "0.0",
        "x-build-id": "TvKnoT3JzLF0q1neA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~analyst-price-targets/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-analyst-price-targets",
                "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/nexgendata~analyst-price-targets/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-analyst-price-targets",
                "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/nexgendata~analyst-price-targets/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-analyst-price-targets",
                "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",
                "required": [
                    "symbols"
                ],
                "properties": {
                    "symbols": {
                        "title": "Stock symbols (tickers)",
                        "type": "array",
                        "description": "Array of US-listed stock tickers to fetch analyst price-target data for. Examples: ['AAPL', 'NVDA', 'TSLA', 'MSFT']. Tickers are case-insensitive — they are upper-cased before lookup. Supports common stock symbols on NYSE, NASDAQ, and major US exchanges. Each symbol returns one record with consensus target, high/low, ratings distribution, and recent analyst actions.",
                        "default": [
                            "AAPL",
                            "NVDA",
                            "TSLA",
                            "MSFT",
                            "AMZN"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Maximum number of records to return",
                        "minimum": 0,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of analyst price-target records to return after all filters apply. Set to 0 to return every input symbol that passes the filters. Useful for testing on small batches before running a full universe scan (S&P 500, Russell 1000, custom watchlist).",
                        "default": 0
                    },
                    "min_upside_pct": {
                        "title": "Minimum upside percentage filter",
                        "minimum": -1000,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Filter out names whose consensus target implies less than this percentage of upside vs current price. Use 20 for high-conviction longs, 50 for deep-value/distressed setups, or a negative number (e.g. -100) to include downside names too. Set to -1000 (default) to disable the filter and return everything. Computed as ((target - current) / current) * 100.",
                        "default": -1000
                    },
                    "consensus_rating": {
                        "title": "Consensus rating filter",
                        "enum": [
                            "all",
                            "Strong Buy",
                            "Buy",
                            "Hold",
                            "Sell",
                            "Strong Sell"
                        ],
                        "type": "string",
                        "description": "Filter records by sell-side consensus rating bucket. 'all' returns everything. Use 'Strong Buy' or 'Buy' to surface street-favorite names, 'Sell' or 'Strong Sell' to surface short candidates and value-trap warnings. The rating is derived from Yahoo Finance's recommendationKey field (1.0–5.0 mean scale).",
                        "default": "all"
                    },
                    "include_recent_actions": {
                        "title": "Include recent analyst actions (last 90 days)",
                        "type": "boolean",
                        "description": "If true, populates the 'recent_actions' field with up to 20 individual sell-side actions from the last 90 days: firm name, rating change, target change, action type (Upgrade/Downgrade/Maintain/Initiate), and date. Disable for lighter payloads if you only need the consensus snapshot.",
                        "default": true
                    },
                    "min_n_analysts": {
                        "title": "Minimum number of contributing analysts",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Drop records where fewer than this many analysts contribute to the consensus target. Use 5 to filter out thinly-covered micro-caps where one outlier dominates the mean. Use 15 to filter to widely-covered names with statistically meaningful consensus. Set to 0 (default) to disable the filter.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
