The Yahoo Finance MCP Server provides tools to fetch and analyze financial data:
Retrieve stock data: Get detailed information about specific stock symbols
Fetch stock-related news: Access recent news articles for stocks
Search: Find stock quotes or news articles using queries
Get top entities by sector: Retrieve top ETFs, mutual funds, companies, growth companies, or performing companies in specific sectors
Analyze sentiment: Perform sentiment analysis on stocks based on provided rationale
Provides a containerized deployment option for the Yahoo Finance MCP server, allowing users to run the server in an isolated environment without installing dependencies.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Yahoo Finance MCP Server get AAPL stock information"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that provides AI assistants with access to Yahoo Finance data via yfinance. Query stock information, financial news, sector rankings, and generate professional financial charts — all from your AI chat.
Stock Data — Company info, financials, valuation metrics, dividends, and trading data
Analyst Data — Consensus targets, estimate/revision trends, recommendation history, and firm-level actions
Financial Statements — Income statement and balance sheet with historical data (EBIT, Invested Capital, etc.)
Financial News — Recent news articles and press releases for any ticker
Search — Find stocks, ETFs, and news across Yahoo Finance
Sector Rankings — Top ETFs, mutual funds, companies, growth leaders, and top performers by sector
Price History — Historical OHLCV data as markdown tables or professional charts
Chart Generation — Candlestick, VWAP, and volume profile charts returned as WebP images
Options Data — Option chains with calls, puts, strike prices, IV, and expiration dates
Ownership Data — Major holders, institutional investors, mutual fund holders, and insider transactions
Fund Look-Through — ETF and mutual-fund holdings, asset classes, sectors, ratings, and operating details
Screeners — Predefined, equity, mutual-fund, and ETF query trees
Related MCP server: DuckDuckGo MCP Server
yfinance_get_ticker_infoRetrieve comprehensive stock data including company info, financials, trading metrics, and governance data.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol (e.g. |
Returns: JSON object with company details, price data, valuation metrics, trading info, dividends, financials, and performance indicators.
yfinance_get_analyst_price_targetsFetch the current price and analyst consensus price targets for a stock.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol (e.g. |
Returns: JSON object with current, low, high, mean, and median price fields. Analyst coverage and available fields vary by symbol.
yfinance_get_analyst_estimatesFetch analyst consensus estimates, revision momentum, recommendations, growth estimates, and earnings history.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol |
| array | No | Any of |
| number | No | Maximum rows per section. Default: |
Returns: Named arrays for available sections plus _metadata containing per-section row counts, truncation status, unavailable sections, and failed sections. A failure in one section does not discard successfully fetched sections.
yfinance_get_upgrades_downgradesFetch analyst upgrades, downgrades, initiations, reiterations, and price-target changes, newest first.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol |
| number | No | Maximum actions to return. Default: |
Returns: JSON object containing upgrades_downgrades records and _metadata with row counts and truncation status. Records can include:
GradeDate: Date and time of the analyst action
Firm: Analyst firm name
ToGrade and FromGrade: New and previous ratings
Action: Rating action
priceTargetAction: Price-target action such as Raises, Lowers, or Maintains
currentPriceTarget and priorPriceTarget: New and previous price targets
Available fields vary by symbol and analyst action.
yfinance_get_ticker_newsFetch recent news articles and press releases for a specific stock.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol |
Returns: JSON array of news items with title, summary, publication date, provider, URL, and thumbnail.
yfinance_searchSearch Yahoo Finance for stocks, ETFs, and news articles.
Parameter | Type | Required | Description |
| string | Yes | Search query — company name, ticker symbol, or keywords |
| string | Yes |
|
Returns: Matching quotes and/or news results depending on search_type.
yfinance_get_topGet top-ranked financial entities within a market sector.
Parameter | Type | Required | Description |
| string | Yes | Market sector (see supported sectors below) |
| string | Yes |
|
| number | No | Number of results to return (default: |
Returns: JSON array of top entities with relevant metrics.
Basic Materials, Communication Services, Consumer Cyclical, Consumer Defensive, Energy, Financial Services, Healthcare, Industrials, Real Estate, Technology, Utilities
yfinance_screenRun Yahoo Finance screeners using either predefined screener keys or custom query trees.
Parameter | Type | Required | Description |
| string/object | Yes | For |
| string | No |
|
| number | No | Result offset |
| number | No | Rows for custom queries; Yahoo maximum is |
| number | No | Rows for predefined queries; Yahoo maximum is |
| string | No | Sort field, for example |
| boolean | No | Sort ascending if |
| string | No | Optional Yahoo user identifier |
| string | No | Optional Yahoo user ID type, commonly |
Returns: JSON screener response from Yahoo Finance, typically including quote rows and metadata.
Custom equity screener example:
{
"query_type": "equity",
"query": {
"operator": "and",
"operands": [
{ "operator": "gt", "operands": ["percentchange", 3] },
{ "operator": "eq", "operands": ["region", "us"] },
{ "operator": "gte", "operands": ["intradayprice", 5] },
{ "operator": "gt", "operands": ["dayvolume", 500000] }
]
},
"sort_field": "percentchange",
"sort_asc": false,
"size": 50
}Custom ETF screener example:
{
"query_type": "etf",
"query": {
"operator": "and",
"operands": [
{ "operator": "eq", "operands": ["categoryname", "Large Blend"] },
{ "operator": "lte", "operands": ["annualreportnetexpenseratio", 0.2] }
]
},
"sort_field": "fundnetassets",
"sort_asc": false,
"size": 25
}yfinance_screen_gappersRun a purpose-built custom screener for opening-session bullish gappers.
Parameter | Type | Required | Description |
| number | No | Minimum percent gap/change from prior close (default: |
| number | No | Minimum intraday price (default: |
| number | No | Minimum day volume (default: |
| number | No | Minimum intraday market cap in USD (default: |
| string | No | Yahoo region code (default: |
| number | No | Number of results (default: |
| number | No | Result offset for pagination (default: |
| boolean | No | Sort by |
Returns: JSON screener response from Yahoo Finance.
yfinance_get_price_historyFetch historical price data and optionally generate technical analysis charts.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol |
| string | No | Time range — |
| string | No | Data granularity — |
| string | No | Chart to generate (omit for tabular data) |
| boolean | No | Include pre-market and post-market data when available (default: |
Chart types:
Value | Description |
| Candlestick chart with volume bars |
| Price chart with Volume Weighted Average Price overlay |
| Candlestick chart with volume distribution by price level |
Returns:
Without chart_type: Markdown table with Date, Open, High, Low, Close, Volume, Dividends, and Stock Splits columns.
With chart_type: Base64-encoded WebP image for efficient token usage.
yfinance_get_financialsFetch financial statements (income statement, balance sheet, and cash flow) with historical data.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol |
| string | No |
|
Returns: JSON object with income statement, balance sheet, and cash flow data for each reporting period.
Income Statement fields: EBIT, Net Income, Tax Provision, Pretax Income, Interest Expense, Total Revenue, Operating Income, EBITDA, Normalized Income
Balance Sheet fields: Stockholders Equity, Total Debt, Cash And Cash Equivalents, Invested Capital, Net Debt, Total Assets, Total Liabilities Net Minority Interest, Net Tangible Assets, Tangible Book Value
Cash Flow fields: Operating Cash Flow, Free Cash Flow, Capital Expenditure, Net Income From Continuing Operations, Depreciation And Amortization, Change In Working Capital, Cash Dividends Paid
yfinance_get_holdersFetch major holders, institutional holders, mutual fund holders, and insider data.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol (e.g. |
| number | No | Maximum rows returned per holder section. Default: |
Returns: JSON object with:
major_holders — Aggregated breakdown where each row has an index label (e.g. insidersPercentHeld, institutionsPercentHeld, institutionsFloatPercentHeld, institutionsCount) and a Value
institutional_holders — Institutional investors; records typically include fields such as Date Reported, Holder, Shares, Value, pctChange, pctHeld
mutualfund_holders — Mutual fund holders; records typically include fields similar to institutional holders
insider_transactions — Recent insider trades; records typically include fields such as Shares, Value, Insider, Position, Transaction, Start Date, Ownership
insider_purchases — Six-month summary where each row describes a category (Purchases, Sales, Net Shares, etc.); records typically include fields such as Insider Purchases Last 6m, Shares, Trans
insider_roster — Known insiders; records typically include fields such as Name, Position, Shares Owned Directly, Most Recent Transaction, Latest Transaction Date
_metadata — Row limit metadata with max_rows and per-section total_rows, returned_rows, and truncated
Holder sections are limited to 10 rows by default to keep responses concise. Pass max_rows: 0 when you need the complete holder datasets. Field names for holder-related datasets are provided by yfinance and may vary by ticker, data availability, and yfinance version.
yfinance_get_fund_dataFetch ETF or mutual-fund portfolio composition and operating details.
Parameter | Type | Required | Description |
| string | Yes | ETF or mutual-fund ticker symbol (for example |
| array | No | Any of |
| number | No | Maximum rows per tabular section. Default: |
Returns: Available fund sections plus _metadata with row limits, per-section truncation, unavailable sections, and failed sections. The mix of sections depends on the fund; for example, equity funds and bond funds expose different portfolio breakdowns.
yfinance_get_option_datesFetch available option expiration dates for a stock.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol (e.g. |
Returns: JSON array of expiration dates in YYYY-MM-DD format.
yfinance_get_option_chainFetch option chain data (calls and puts) for a stock with available strike prices.
Parameter | Type | Required | Description |
| string | Yes | Stock ticker symbol |
| string | No | Option expiration date in YYYY-MM-DD format. Omit to fetch all dates. |
| string | No |
|
Returns: JSON object keyed by expiration date, with calls and/or puts data including:
contractSymbol: Option contract identifier
strike: Strike price
lastPrice: Last traded price
bid/ask: Bid and ask prices
volume: Trading volume
openInterest: Open interest
impliedVolatility: IV
inTheMoney: Whether option is ITM
contractSize: Contract size (REGULAR)
currency: Currency (USD)
Add the following to your MCP client configuration:
{
"mcpServers": {
"yfmcp": {
"command": "uvx",
"args": ["yfmcp@latest"]
}
}
}{
"mcpServers": {
"yfmcp": {
"command": "docker",
"args": ["run", "-i", "--rm", "narumi/yfinance-mcp"]
}
}
}Clone the repository and install dependencies:
git clone https://github.com/narumiruna/yfinance-mcp.git
cd yfinance-mcp
uv syncAdd the following to your MCP client configuration:
{
"mcpServers": {
"yfmcp": {
"command": "uv",
"args": [
"run",
"--directory",
"/path/to/yfinance-mcp",
"yfmcp"
]
}
}
}Replace /path/to/yfinance-mcp with the actual path to your cloned repository.
This repository includes .codex/config.toml, which registers the local yfmcp MCP server for Codex CLI using uv run yfmcp. After cloning the repository and running uv sync, open Codex CLI from the repository root and try prompts such as:
Show VOO ticker info
Show VOO price history for the last 5 days
Find the ticker symbol for Toyota
Get AAPL option expiration datesPython ≥ 3.12
uv package manager
uv sync --extra devuv run ruff check .
uv run ruff format .uv run ty check src testsuv run pytest -v -s --cov=src testsSee the demo chatbot in its dedicated repository: yfinance-mcp-demo
Made with contrib.rocks.
This project is licensed under the MIT License.
Fetch consensus estimates, EPS/revenue trends, revisions, recommendations, and earnings history.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') | |
| max_rows | No | Maximum rows per section. Use 0 to return all rows. | |
| sections | No | Optional analyst sections: recommendations, earnings_estimate, revenue_estimate, eps_trend, eps_revisions, earnings_history, and growth_estimates. Omit to return all sections. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the scope of data (consensus estimates, trends, etc.) but discloses no additional behavioral traits like pagination, rate limits, or the behavior of the 'sections' parameter beyond what the schema already provides.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that efficiently lists the key data types covered. No filler, no redundancy, and it directly conveys the tool's scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The structured schema (3 params with 100% coverage), annotations (read-only, idempotent), and presence of an output schema cover safety and parameters. The description sufficiently conveys the core purpose, but lacks usage alternatives, keeping it just below the top tier.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meeting the baseline of 3. The description lists content areas that map to the 'sections' parameter, but adds no new meaning about the 'symbol' or 'max_rows' parameters beyond what the schema already details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Fetch' and identifies the resource as analyst estimates, listing key content areas (consensus estimates, EPS/revenue trends, revisions, recommendations, earnings history). This clearly differentiates from sibling tools like price targets or news, though it does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool over alternatives. Sibling tools exist (e.g., yfinance_get_analyst_price_targets, yfinance_get_upgrades_downgrades) but no usage context, prerequisites, or exclusions are offered.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the current price and analyst consensus price targets for a stock.
Returns a JSON object with the fields supplied by Yahoo Finance:
- current: Current market price
- low: Lowest analyst price target
- high: Highest analyst price target
- mean: Mean analyst price target
- median: Median analyst price target
Analyst coverage and available fields vary by symbol.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds meaningful context by disclosing that analyst coverage and available fields vary by symbol, and by enumerating the exact return fields. This goes beyond the structured annotations and clarifies potential variability.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured. It front-loads the main purpose in one sentence, then uses a bullet list to clearly present return fields. Every sentence and bullet earns its place with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with a single well-documented parameter and output schema present. The description covers the return fields and adds a variability caveat, which is sufficient for the agent to understand behavior. Minor edge cases (e.g., missing coverage) are not explicitly detailed, but the variability warning implies them, so this is near-complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the only parameter 'symbol' with examples and a clear description (100% coverage). The description does not add any additional parameter semantics or format details beyond what the schema already provides, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Fetch') and the resource ('current price and analyst consensus price targets'), which is specific and distinguishes it from sibling tools like get_upgrades_downgrades that focus on analyst recommendations. This is a clear and unambiguous purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives. The description only states what it does, and while the sibling list implies different use cases (e.g., upgrades/downgrades for analyst actions), no direct comparisons or exclusions are provided. Guidance is only implied at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch financial statements (income statement, balance sheet, and cash flow) with historical data.
Returns JSON with income statement, balance sheet, and cash flow data across reporting periods.
Use the data to analyze trends, calculate ratios, or compare periods.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') | |
| frequency | No | Reporting frequency: 'annual' for yearly, 'quarterly' for quarterly, or 'ttm' for trailing twelve months | annual |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true, so the safety profile is clear. Description adds that it returns historical data and the structure of the output (income, balance sheet, cash flow), which is useful but not extensive behavioral context. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each serving a purpose: first defines the action, second describes output, third suggests usage. No unnecessary words or redundancy. Appropriately sized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (so return format is documented elsewhere), the description covers the tool's purpose, output structure, and typical use cases. It is adequate for a simple read-only tool, though it could mention data range or limitations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage with descriptions for both parameters (symbol and frequency). Description does not add any new semantics beyond the schema; it only mentions 'historical data' which is implied by the tool's nature. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it fetches financial statements (income, balance sheet, cash flow) with historical data. Verb 'Fetch' and resource 'financial statements' are specific, and the tool is well-distinguished from siblings like price history or holders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description says 'Use the data to analyze trends, calculate ratios, or compare periods' which implies usage context but does not explicitly state when to use vs alternatives or when not to use. No exclusions or comparisons to siblings provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch ETF or mutual-fund composition, holdings, exposures, ratings, and operating details.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | ETF or mutual fund ticker symbol (e.g., 'SPY', 'BND', 'VFIAX') | |
| max_rows | No | Maximum rows per tabular section. Use 0 to return all rows. | |
| sections | No | Optional fund sections: description, fund_overview, fund_operations, asset_classes, top_holdings, equity_holdings, bond_holdings, bond_ratings, and sector_weightings. Omit to return all sections. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, open-world behavior. The description's 'Fetch' is consistent. It adds no additional behavioral context such as potential response sizes, rate limits, or pagination, but the max_rows parameter in the schema partially addresses that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, clear sentence that packs the tool's purpose and scope without extraneous detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core data types exposed by the tool and an output schema exists to define return structure. It lacks explicit usage guidance but is otherwise sufficient for understanding the tool's domain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All three parameters (symbol, max_rows, sections) have thorough descriptions in the schema, so the description does not need to elaborate. It adds no extra parameter semantics beyond the schema's high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Fetch' and identifies the exact resource: ETF or mutual-fund composition, holdings, exposures, ratings, and operating details. This clearly differentiates it from sibling tools focused on analyst data, news, price history, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the description clearly implies use for fund-related data, it provides no explicit guidance on when to choose this tool over siblings such as yfinance_get_holders or yfinance_get_ticker_info. It neither names alternatives nor states exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch major holders, institutional holders, mutual fund holders, and insider data.
Returns JSON with:
- major_holders: Aggregated breakdown including insider % held, institutional % held,
institutional % float held, and institution count.
- institutional_holders: List of institutional investors with shares held, date reported,
value, and % change.
- mutualfund_holders: List of mutual fund holders with same fields.
- insider_transactions: Recent insider transactions including shares, value, transaction
type, and date.
- insider_purchases: Summary of insider buy/sell activity over the last 6 months.
- insider_roster: List of known insiders by name and position.
Use this to analyze ownership concentration, insider activity, and institutional interest.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') | |
| max_rows | No | Maximum rows returned per holder section. Use 0 to return all rows. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds value by detailing the JSON structure returned, including sections like major_holders and insider_transactions, which goes beyond the annotations and output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a clear first sentence stating the purpose, followed by a bulleted list of return sections. It is well-structured and front-loaded, though the bullet list could be slightly more compact without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema and comprehensive annotations, the description provides sufficient context about the data returned. It lists the sections but does not cover edge cases like empty results or rate limits. However, for a read-only tool with openWorldHint, this is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description does not add additional meaning to the parameters beyond what is in the schema (symbol and max_rows). The schema already provides descriptions for both parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches major holders, institutional holders, mutual fund holders, and insider data. It distinguishes from siblings like yfinance_get_financials which deal with financial statements, making the purpose specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Use this to analyze ownership concentration, insider activity, and institutional interest,' providing clear context for when to use. It does not explicitly mention when not to use or list alternatives, but the sibling tools cover different data types, making the usage fairly clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch option chain data (calls and puts) for a stock with available strike prices.
Returns JSON with calls and/or puts data for each expiration date.
JSON fields include:
- contractSymbol: Option contract identifier
- strike: Strike price
- lastPrice: Last traded price
- bid/ask: Bid and ask prices
- volume: Trading volume
- openInterest: Open interest
- impliedVolatility: Implied volatility (IV)
- inTheMoney: Whether option is ITM
- contractSize: Contract size (REGULAR)
- currency: Currency (USD)
Use this to analyze options pricing, IV surfaces, and strike levels.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') | |
| option_type | No | Which options to return: 'calls', 'puts', or 'all' (both calls and puts). | all |
| expiration_date | No | Option expiration date in YYYY-MM-DD format. Use the 'yfinance_get_option_dates' tool to find available dates, or omit to fetch all available expiration dates. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds value by detailing the JSON fields returned (e.g., contractSymbol, strike, impliedVolatility) and the intended use case for options analysis, without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the purpose and then lists the JSON fields. It is moderately concise; the field list is helpful but could be slightly more condensed. However, it remains clear and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is sufficiently complete for a data-fetching tool: it explains what data is returned, how to use parameters, and references a sibling tool for dates. The presence of an output schema (though not provided) is compensated by the detailed field listing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for all three parameters. The description adds semantic value by explaining the expiration_date parameter's relationship with yfinance_get_option_dates and by listing the fields in the output, which aids understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches option chain data (calls and puts) for a stock, with specific mention of strike prices and expiration dates. It distinguishes itself from sibling tools like yfinance_get_option_dates by explicitly referencing it for finding available dates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implicit usage guidance by referencing yfinance_get_option_dates to obtain expiration dates, but it does not explicitly state when to use this tool over others or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch available option expiration dates for a stock.
Returns JSON array of expiration dates in YYYY-MM-DD format.
Use these dates with the 'yfinance_get_option_chain' tool to fetch
the options chain for a specific date.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the return format (JSON array of YYYY-MM-DD dates) which adds value beyond annotations. Annotations already indicate read-only, non-destructive, idempotent behavior, so the description's format detail is sufficient for transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only three sentences, front-loaded with purpose, and each sentence adds distinct value: purpose, return format, and cross-reference to sibling tool. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single parameter, simple return), the description covers all necessary context: what it does, what it returns, and how to use it with a related tool. Output schema exists so return structure is further clarified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with the symbol parameter already well-described. The description adds no extra parameter meaning beyond what the schema provides, meeting the baseline expectation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches available option expiration dates for a stock, using specific verb 'fetch' and resource 'option expiration dates'. It distinguishes from sibling tools by mentioning usage with yfinance_get_option_chain.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells when to use this tool (to get expiration dates) and how to use it with yfinance_get_option_chain. However, it does not explicitly state when not to use it or mention any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch historical price data and optionally generate technical analysis charts.
When chart_type is None, returns Markdown table with columns:
- Date: Trading date (index)
- Open: Opening price
- High: Highest price
- Low: Lowest price
- Close: Closing price
- Volume: Trading volume
- Dividends: Dividend payments (if any)
- Stock Splits: Split events (if any)
When chart_type is specified, returns a chart image:
- 'price_volume': Candlestick chart with volume bars
- 'vwap': Price with Volume Weighted Average Price overlay
- 'volume_profile': Volume distribution by price level
Set prepost=True to include pre-market and post-market data when available.
Note: Not all period/interval combinations are valid. Minute intervals (1m, 5m, etc.)
only work with short periods (1d, 5d).
| Name | Required | Description | Default |
|---|---|---|---|
| period | No | Time range: '1d'/'5d' (days), '1mo'/'3mo'/'6mo' (months), '1y'/'2y'/'5y'/'10y' (years), 'ytd' (year-to-date), 'max' (all available data) | 1mo |
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') | |
| prepost | No | Include pre-market and post-market data when available | |
| interval | No | Data granularity: '1m'/'5m'/'15m'/'30m' (minutes), '1h' (hour), '1d'/'5d' (days), '1wk' (week), '1mo'/'3mo' (months). Short intervals require short periods (e.g., '1m' interval only works with '1d'/'5d' period) | 1d |
| chart_type | No | Optional visualization: 'price_volume' (candlestick chart with volume bars), 'vwap' (Volume Weighted Average Price overlay), 'volume_profile' (volume distribution by price level). Omit for tabular data |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint=true, destructiveHint=false) are supported. The description adds detail about output formats: Markdown table with specific columns or chart images depending on chart_type. It also notes validity constraints for intervals, going beyond structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: first sentence as command, then bullet points for table columns, chart options, prepost note, and validity warning. Every sentence adds value; no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main output cases (table vs. chart) and common constraints. It lacks details on error handling for invalid combinations, but given the presence of annotations and output schema, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by summarizing chart_type options and warning about interval/period compatibility, which is not fully covered in schema descriptions. However, most parameter meaning is already in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetch historical price data and optionally generate technical analysis charts.' It specifies the resource (historical price data) and the optional chart generation. This distinguishes it from sibling tools that focus on financials, holders, news, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on chart_type options and warns about valid period/interval combinations. It also explains prepost behavior. However, it does not explicitly mention when to use this tool versus alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve comprehensive stock data including company information, financials, trading metrics and governance.
Returns JSON object with fields including:
- Company: symbol, longName, sector, industry, longBusinessSummary, website, city, country
- Price: currentPrice, previousClose, open, dayHigh, dayLow, fiftyTwoWeekHigh, fiftyTwoWeekLow
- Valuation: marketCap, enterpriseValue, trailingPE, forwardPE, priceToBook, pegRatio
- Trading: volume, averageVolume, averageVolume10days, bid, ask, bidSize, askSize
- Dividends: dividendRate, dividendYield, exDividendDate, payoutRatio
- Financials: totalRevenue, revenueGrowth, earningsGrowth, profitMargins, operatingMargins
- Performance: beta, fiftyDayAverage, twoHundredDayAverage, trailingEps, forwardEps
Note: Available fields vary by security type. Timestamps are converted to readable dates.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint, idempotentHint, etc. The description adds behavioral nuances: fields vary by security type, timestamps converted. This goes beyond annotations without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized with bulleted categories, but slightly verbose with overlapping categories (e.g., Price/Valuation/Trading). Front-loaded purpose is clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity, annotations richness, and output schema implied via field listing, the description is complete. It provides sufficient detail on return fields and behavior for agent decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The sole parameter 'symbol' is well-described in the input schema with examples, achieving 100% coverage. The description adds no extra parameter meaning beyond what schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves comprehensive stock data including specific categories like company info, financials, trading metrics, and governance. It distinguishes from sibling tools by emphasizing comprehensiveness vs. specialized tools like yfinance_get_financials.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when full stock details are needed, but lacks explicit guidance on when to choose this over siblings like yfinance_get_financials or yfinance_get_price_history. No 'when not' or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch recent news articles and press releases for a specific stock.
Returns JSON array where each news item has:
- id: Unique article identifier
- content: Object containing:
- title: Article headline
- summary: Brief article summary
- pubDate: Publication date (ISO 8601 format)
- provider: Object with displayName (e.g., "Yahoo Finance") and url
- canonicalUrl: Object with article url, site, region, lang
- thumbnail: Object with image URLs and resolutions
- contentType: Type of content (e.g., "STORY", "VIDEO")
Use this to track company announcements, market sentiment, and breaking news.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and idempotentHint=true. The description adds value by detailing the output JSON structure (fields like id, content, title, etc.), which provides behavioral context beyond the annotations. It does not contradict any annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (three sentences) and front-loaded with the core action. Every sentence serves a purpose: action, output structure, usage guidance. No unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter, a rich output schema, and annotations, the description covers the output in detail and provides usage context. It is slightly incomplete as it does not mention any result limits or pagination, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the symbol parameter with examples. The description does not add any meaning beyond the schema; it focuses on the output. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches news for a specific stock using a specific verb ('Fetch') and resource ('recent news articles and press releases'). It distinguishes this tool from siblings like yfinance_get_financials and yfinance_get_ticker_info, which serve different data types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear use case ('track company announcements, market sentiment, and breaking news') but does not explicitly contrast with alternatives or state when not to use this tool. No sibling differentiation or exclusion criteria are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get top-ranked financial entities within a sector.
This unified tool provides access to various rankings:
- ETFs and mutual funds focused on the sector
- Largest companies by market capitalization
- Fastest-growing companies by revenue/earnings
- Best-performing stocks by price appreciation
Returns JSON data with relevant metrics for each entity type.
| Name | Required | Description | Default |
|---|---|---|---|
| top_n | No | Number of top entities to retrieve per category/industry | |
| sector | Yes | Market sector (e.g., 'Technology', 'Healthcare', 'Financial Services') | |
| top_type | Yes | Type of entities to retrieve: 'top_etfs' (sector ETFs), 'top_mutual_funds' (sector mutual funds), 'top_companies' (largest by market cap), 'top_growth_companies' (fastest revenue/earnings growth), 'top_performing_companies' (best stock price performance) |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool as read-only, non-destructive, idempotent, and open world. The description adds that it returns JSON data with metrics, but does not elaborate on behaviors like rate limits or data freshness. The description does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the main purpose, and lists entity types without unnecessary detail. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is fairly complete given the presence of an output schema and detailed input schema. It covers the purpose and entity types, though it could briefly mention that results are sorted by relevance (implied by 'top'). Minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with detailed parameter descriptions in the input schema. The tool description adds a narrative list of top_type options but does not provide new constraints or clarifications beyond what the schema already offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves top-ranked financial entities within a sector. It lists specific ranking types (ETFs, mutual funds, largest companies, etc.), distinguishing it from sibling tools that focus on single entities or historical data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for sector-level rankings but does not explicitly state when to use this tool over alternatives like yfinance_get_ticker_info or yfinance_search. No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch analyst upgrades, downgrades, initiations, and price target changes.
Returns analyst actions newest first. Fields supplied by Yahoo Finance can include:
- GradeDate: Date and time of the analyst action
- Firm: Analyst firm name
- ToGrade and FromGrade: New and previous ratings
- Action: Rating action, such as upgrade, downgrade, initiation, or reiteration
- priceTargetAction: Price target action, such as Raises, Lowers, or Maintains
- currentPriceTarget and priorPriceTarget: New and previous price targets
Available fields vary by symbol and analyst action.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT') | |
| max_rows | No | Maximum analyst actions to return, newest first. Use 0 to return all rows. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is known. The description adds that results are returned newest first and that available fields vary by symbol and analyst action, which is useful contextual behavior. However, it does not cover potential missing data or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized, with a clear opening sentence followed by a structured field list. It provides useful detail without excessive verbosity, though the field enumeration could be considered slightly long.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with only two parameters and a known output schema, the description adequately explains the returned data, ordering, and field variability. It lacks alternative usage guidance, but that dimension is separate. Overall, it is complete enough for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers 100% of parameters with descriptions, including symbol and max_rows semantics. The description does not add parameter-specific details beyond what the schema already provides, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches analyst upgrades, downgrades, initiations, and price target changes, specifying the resource and action. However, it does not differentiate from the sibling tool yfinance_get_analyst_price_targets, which may overlap on price target changes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like yfinance_get_analyst_price_targets. The description only describes functionality without any when/when-not or alternative references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run a Yahoo Finance screener query.
Supports predefined Yahoo screener keys and custom equity, mutual-fund, or ETF query trees.
| Name | Required | Description | Default |
|---|---|---|---|
| size | No | Rows to return for custom queries. Yahoo maximum is 250. | |
| count | No | Rows to return for predefined queries. Yahoo maximum is 250. | |
| query | Yes | Screener query. For query_type='predefined': string key like 'day_gainers'. For query_type='equity', 'fund', or 'etf': query tree object with {operator, operands} nodes. | |
| offset | No | Result offset. | |
| user_id | No | Optional Yahoo user id. | |
| sort_asc | No | Sort ascending if true, descending if false. | |
| query_type | No | Query mode: 'predefined', 'equity', 'fund', or 'etf'. | predefined |
| sort_field | No | Sort field, for example 'percentchange'. | |
| user_id_type | No | Optional Yahoo user id type, commonly 'guid'. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety traits. The description adds capability scope (predefined keys and custom query trees) but not behavioral nuances such as response size limits or pagination behavior. Since annotations carry the safety burden, a 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action and immediately followed by the key distinction between predefined and custom queries. No filler or redundancy, earning a top score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (9 parameters) but rich schema (100% param coverage) and presence of an output schema, the description is sufficiently complete. It covers the core purpose and the two query modes, though it omits nuanced guidance like when to use count vs. size, which the schema already covers. This is above average but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds a high-level note about query being either a predefined key or a query tree, but this only lightly supplements the schema's already detailed parameter descriptions for query and query_type. It does not explain interactions between size/count or sort fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb and resource: 'Run a Yahoo Finance screener query.' It further distinguishes itself from siblings like yfinance_screen_gappers and yfinance_get_top by mentioning support for both predefined screener keys and custom query trees, which is this tool's unique scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by stating it supports predefined and custom queries, but it does not explicitly say when to use this tool over alternatives like yfinance_screen_gappers or yfinance_get_top. No exclusions or alternative tool references are provided, so guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run a custom equity screener tuned for opening-session stock gappers.
| Name | Required | Description | Default |
|---|---|---|---|
| size | No | Rows to return. Yahoo maximum is 250. | |
| offset | No | Result offset for pagination. | |
| region | No | Yahoo screener region code, for example 'us'. | us |
| sort_asc | No | Sort by percentchange ascending if true, descending if false. | |
| min_price | No | Minimum current intraday price. | |
| min_volume | No | Minimum intraday trading volume. | |
| min_market_cap | No | Minimum intraday market cap in USD. | |
| min_percent_change | No | Minimum percent change from prior close, for example 3.0 for +3%. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide key behavioral traits (readOnlyHint=true, idempotentHint=true), and the description adds the specific tuning for gappers, which complements rather than contradicts. The description adds value beyond the annotations without being redundant.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence of only 11 words, with no fluff or repetition. It is optimally concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of a full output schema, annotations, and 100% schema coverage, the description provides sufficient context. No additional information is needed for an agent to use this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the schema already explains each parameter thoroughly. The description adds no additional parameter semantics, meeting the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies a specific verb ('Run') and resource ('equity screener') with a unique tuning ('opening-session stock gappers'), distinguishing it from the sibling 'yfinance_screen' which is a general screener. This leaves no ambiguity about the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or prerequisites. While the tool's purpose implies usage for gappers, the lack of explicit guidelines lowers the score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Yahoo Finance for stocks, ETFs, and news articles.
Returns JSON with search results based on search_type:
- 'quotes': Array of securities with:
- symbol: Ticker symbol
- shortname/longname: Company name
- quoteType: Security type (EQUITY, ETF, MUTUALFUND, etc.)
- exchange: Exchange code
- sector: Business sector
- industry: Industry classification
- score: Search relevance score
- 'news': Array of articles with:
- uuid: Article identifier
- title: Headline
- publisher: News source
- link: Article URL
- providerPublishTime: Unix timestamp
- relatedTickers: Array of related symbols
- thumbnail: Image URLs
- 'all': Object with both 'quotes' and 'news' arrays
Use this to find ticker symbols, discover related securities, or search financial news.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query - company name, ticker symbol, or keywords | |
| search_type | Yes | Filter results: 'all' (quotes + news), 'quotes' (stocks/ETFs only), or 'news' (articles only) |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly, idempotent, openWorld. Description adds that it returns JSON with specific structures for quotes, news, or both. No mention of rate limits or other constraints, but sufficient for a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is detailed with clear sections for each search_type output. Could be slightly more concise, but structure aids readability and understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has output schema, and description fully explains return values for each search_type. Input parameters are well-described. Context is complete for a search tool, with no missing behavioral details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with descriptions for both parameters. Description adds substantial value by explaining how search_type modifies output and detailing return fields for each type, which goes beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it searches Yahoo Finance for stocks, ETFs, and news, differentiating from sibling tools like yfinance_get_ticker_info and yfinance_get_ticker_news. It explicitly says 'Use this to find ticker symbols, discover related securities, or search financial news.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description explains how to filter results via search_type parameter and what each type returns. It implicitly guides usage but does not explicitly state when to avoid or compare with alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.14.0yfinance_get_analyst_estimatesyfinance_get_fund_datayfinance_screen3 fields changedInput schema / properties / query / descriptionPrevious value: -"Screener query. For query_type='predefined': string key like 'day_gainers'. For query_type='equity' or 'fund': query tree object with {operator, operands} nodes."New value: +"Screener query. For query_type='predefined': string key like 'day_gainers'. For query_type='equity', 'fund', or 'etf': query tree object with {operator, operands} nodes."Input schema / properties / query_type / descriptionPrevious value: -"Query mode: 'predefined', 'equity', or 'fund'."New value: +"Query mode: 'predefined', 'equity', 'fund', or 'etf'."Input schema / properties / query_type / enumPrevious value: -[
- "predefined",
- "equity",
- "fund"
-]New value: +[
+ "predefined",
+ "equity",
+ "fund",
+ "etf"
+]v0.13.0yfinance_get_analyst_price_targetsyfinance_get_upgrades_downgradesv0.12.0yfinance_screenyfinance_screen_gappersv0.11.3get_price_historyget_ticker_infoget_ticker_newsget_topsearchyfinance_get_financialsyfinance_get_holdersyfinance_get_option_chainyfinance_get_option_datesyfinance_get_price_historyyfinance_get_ticker_infoyfinance_get_ticker_newsyfinance_get_topyfinance_searchv1.0.0get_price_historyget_ticker_infoget_ticker_newsget_topsearchScored across 13 tools
Each tool covers a distinct data domain (financials, quotes, analyst actions, news, search, screeners, price history, options, holders). The only potential overlap is between the generic screener and the specialized gapper/top tools, but their descriptions clearly differentiate their purposes.
All tools share the yfinance_ prefix and mostly follow a verb_noun structure (e.g., get_financials, get_ticker_info). A few tools like search, screen, and screen_gappers deviate from the 'get_' pattern, creating minor inconsistency, but the overall naming remains predictable and readable.
With 13 tools, the server is well-scoped for a comprehensive financial data API. Each tool serves a meaningful purpose, and the count is within the ideal range, avoiding both bloat and thinness.
The toolset covers major Yahoo Finance data categories including fundamentals, quotes, analyst targets, upgrades/downgrades, news, search, screeners, price history, options, and holders. This is a comprehensive surface for the stated domain with no obvious dead ends.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for stocksense-ai documentation, generated by doc2mcp.
A simple MCP server built with FastMCP and python
Finnhub MCP — wraps Finnhub Stock API (finnhub.io)
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/narumiruna/yfinance-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
