Provides tools for accessing financial market data through Polygon.io API, including ticker details, real-time quotes, historical price aggregates, market status, and news articles related to specific tickers.
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., "@Polygon MCP Server what's the latest quote for Apple stock?"
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 tools for interacting with the Polygon.io API for market data.
This MCP server provides the following tools:
get_ticker_details - Get details about a ticker symbol
get_latest_quote - Get real-time quote for a ticker
get_aggregates - Get aggregate bars for a ticker
get_daily_open_close - Get daily open/close prices
get_market_status - Check if markets are open
get_ticker_news - Get news articles for a ticker
list_tickers - Search/list available tickers
get_snapshot - Get snapshot of ticker(s)
Related MCP server: Alpaca Trading MCP Server
Clone this repository
Install dependencies:
npm installBuild the server:
npm run buildThe server requires the following environment variable:
POLYGON_API_KEY - Your Polygon.io API key
Add the following to your MCP settings file:
{
"mcpServers": {
"polygon": {
"command": "node",
"args": ["/path/to/polygon-server/build/index.js"],
"env": {
"POLYGON_API_KEY": "your-api-key"
}
}
}
}{
"tool": "get_market_status",
"arguments": {}
}{
"tool": "get_ticker_details",
"arguments": {
"ticker": "AAPL"
}
}{
"tool": "get_aggregates",
"arguments": {
"ticker": "AAPL",
"timespan": "day",
"from": "2024-01-01",
"to": "2024-01-31"
}
}{
"tool": "get_ticker_news",
"arguments": {
"ticker": "TSLA",
"limit": 5
}
}Run in watch mode: npm run watch
Run tests: npm test
Lint code: npm run lint
For more information about the Polygon.io API, visit: https://polygon.io/docs
MIT
Get aggregate bars for a ticker
| Name | Required | Description | Default |
|---|---|---|---|
| ticker | Yes | Ticker symbol (e.g., AAPL) | |
| timespan | Yes | Size of the time window | |
| from | Yes | Start date (YYYY-MM-DD format) | |
| to | Yes | End date (YYYY-MM-DD format) | |
| adjusted | No | Whether to adjust for splits (default: true) | |
| sort | No | Sort order (default: asc) | |
| limit | No | Number of results (default: 120, max: 50000) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but only states the basic action without details on rate limits, authentication needs, error handling, or output format. It doesn't mention whether this is a read-only operation, if it has side effects, or any performance considerations, which are critical for an agent to use it effectively.
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 with no wasted words, making it highly concise and easy to parse. It front-loads the essential information ('Get aggregate bars for a ticker'), though it could benefit from more detail given the lack of annotations and sibling context.
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 complexity of 7 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'aggregate bars' are, how the output is structured, or any behavioral traits, leaving significant gaps for an agent to understand the tool's full context and usage.
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 schema description coverage is 100%, so the input schema fully documents all parameters with descriptions and enums. The description adds no additional meaning beyond the schema, such as explaining how 'aggregate bars' relate to parameters like 'timespan' or 'adjusted'. This meets the baseline for high schema coverage but doesn't enhance understanding.
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 ('Get') and resource ('aggregate bars for a ticker'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_daily_open_close' or 'get_latest_quote', which also retrieve financial data for tickers, leaving some ambiguity about when to choose this specific tool.
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 versus alternatives like 'get_daily_open_close' or 'get_latest_quote'. It lacks context about scenarios where aggregate bars are preferred over other data types, such as for time-series analysis or specific financial metrics, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get daily open/close prices
| Name | Required | Description | Default |
|---|---|---|---|
| ticker | Yes | Ticker symbol (e.g., AAPL) | |
| date | Yes | Date (YYYY-MM-DD format) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't add any context about traits such as data freshness, rate limits, authentication needs, or error handling. This is a significant gap for a tool that likely queries financial data.
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, efficient sentence with zero waste. It's front-loaded and gets straight to the point, making it easy for an agent to parse quickly without unnecessary details.
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 lack of annotations and output schema, the description is incomplete. It doesn't address what the tool returns (e.g., price values, timestamps, or error cases) or behavioral aspects like data sources or limitations. For a financial data tool, this leaves critical gaps in understanding.
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, clearly documenting both parameters (ticker and date). The description doesn't add any meaning beyond this, as it doesn't explain parameter interactions or provide examples. Baseline 3 is appropriate since the schema does the heavy lifting.
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 ('Get') and the resource ('daily open/close prices'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its siblings like 'get_latest_quote' or 'get_snapshot', which might also provide price-related data, so it doesn't reach the highest score.
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 versus alternatives like 'get_latest_quote' or 'get_aggregates'. It lacks context about specific use cases, prerequisites, or exclusions, leaving the agent to infer usage based on the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get real-time quote for a ticker
| Name | Required | Description | Default |
|---|---|---|---|
| ticker | Yes | Ticker symbol (e.g., AAPL) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'real-time' which hints at current data, but doesn't cover important aspects like rate limits, authentication needs, data freshness guarantees, error conditions, or what the return format might look like. This is inadequate for a tool that likely interacts with external APIs.
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, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple tool with one parameter and is perfectly 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?
For a tool that fetches real-time financial data (implied complexity), with no annotations and no output schema, the description is insufficient. It doesn't explain what a 'quote' includes (price? volume? bid/ask?), doesn't mention data sources or limitations, and provides no behavioral context. The agent would be operating with significant uncertainty.
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 schema description coverage is 100%, with the single parameter 'ticker' well-documented in the schema. The description doesn't add any meaningful parameter information beyond what the schema already provides (it just repeats 'for a ticker'), so it meets the baseline for high schema 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 clearly states the action ('Get real-time quote') and resource ('for a ticker'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'get_snapshot' or 'get_ticker_details' that might also provide quote-related data, so it doesn't reach the highest score.
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 versus alternatives like 'get_snapshot' or 'get_daily_open_close'. It lacks context about use cases, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check if markets are open
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states what the tool does but doesn't disclose behavioral traits such as whether it's read-only, requires authentication, has rate limits, or what the return format looks like. This is a significant gap for a tool with zero annotation coverage.
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, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to understand at a glance without unnecessary elaboration.
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 simplicity (0 parameters, no output schema), the description is adequate but has clear gaps. It lacks behavioral context and usage guidelines, which are important even for simple tools. However, it does state the core purpose clearly, making it minimally viable.
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 tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, but it appropriately doesn't mention any. A baseline of 4 is applied since no parameters exist.
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 'Check if markets are open' clearly states the tool's purpose with a specific verb ('Check') and resource ('markets'), making it immediately understandable. However, it doesn't differentiate from sibling tools like get_aggregates or get_daily_open_close, which prevents a perfect score.
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 versus alternatives. With siblings like get_latest_quote or get_snapshot that might provide related market data, there's no indication of context, prerequisites, or exclusions for this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get snapshot of ticker(s)
| Name | Required | Description | Default |
|---|---|---|---|
| tickers | Yes | Comma-separated list of tickers (e.g., AAPL,MSFT,GOOGL) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Get snapshot' but doesn't clarify if this is a read-only operation, requires authentication, has rate limits, or what the output format might be. This leaves significant gaps for a tool that likely fetches financial data.
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, efficient sentence with no wasted words. However, it's overly terse and could benefit from slightly more detail to improve clarity without sacrificing brevity.
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 lack of annotations and output schema, the description is incomplete. It doesn't explain what a 'snapshot' returns (e.g., current prices, volumes, etc.), leaving the agent uncertain about the tool's behavior and output, which is inadequate for a data-fetching tool in a financial context.
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 schema description coverage is 100%, with the 'tickers' parameter fully documented as a comma-separated list. The description adds no additional meaning beyond what the schema provides, such as examples or constraints, so it meets the baseline score of 3 for high schema 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 'Get snapshot of ticker(s)' states the basic action (get) and target (snapshot of tickers), but it's vague about what a 'snapshot' entails compared to siblings like 'get_ticker_details' or 'get_latest_quote'. It doesn't specify what data the snapshot includes, making it less distinct from 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?
No guidance is provided on when to use this tool versus siblings such as 'get_ticker_details' or 'get_latest_quote'. The description implies it retrieves data for tickers, but without context on what makes a 'snapshot' different, the agent lacks clear usage criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details about a ticker symbol
| Name | Required | Description | Default |
|---|---|---|---|
| ticker | Yes | Ticker symbol (e.g., AAPL) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'gets details' but doesn't specify what details are returned, whether it's a read-only operation, error handling, or any rate limits. This is inadequate for a tool with no annotation coverage.
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, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to parse quickly.
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 no annotations and no output schema, the description is incomplete. It doesn't explain what 'details' are returned, error cases, or how it differs from sibling tools. For a tool in a set with multiple similar functions, this leaves significant gaps for an agent.
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 'ticker' parameter. The description doesn't add any meaning beyond what's in the schema (e.g., examples, constraints, or context), so it meets the baseline for high schema 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 clearly states the action ('Get details') and resource ('about a ticker symbol'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_snapshot' or 'get_latest_quote' which might also provide ticker details, leaving room for ambiguity about what specific details are returned.
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 'get_snapshot' or 'get_latest_quote'. The description lacks context about what distinguishes it from siblings, leaving the agent to infer usage based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get news articles for a ticker
| Name | Required | Description | Default |
|---|---|---|---|
| ticker | Yes | Ticker symbol (e.g., AAPL) | |
| limit | No | Number of articles to return (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It doesn't mention whether this is a read-only operation, potential rate limits, authentication needs, or what format/news sources are returned. For a tool with no annotations, this is insufficient behavioral context.
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 extremely concise with a single, clear sentence that gets straight to the point. There's no wasted language or unnecessary elaboration, making it efficiently front-loaded and easy to parse.
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 no annotations and no output schema, the description is incomplete for a tool that likely returns complex news data. It doesn't explain the return format, article structure, or any behavioral traits, leaving significant gaps in understanding how to use this tool effectively.
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 description doesn't add any parameter semantics beyond what the input schema already provides (100% coverage). The schema fully documents both parameters (ticker and limit with default), so the baseline score of 3 is appropriate as the description doesn't compensate or add extra meaning.
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 'Get news articles for a ticker' clearly states the action (get) and resource (news articles for a ticker), making the purpose immediately understandable. However, it doesn't distinguish this tool from potential sibling tools that might also retrieve news-related data, keeping it from a perfect score.
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 versus alternatives like 'get_ticker_details' or other sibling tools. It lacks context about use cases, prerequisites, or exclusions, leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search/list available tickers
| Name | Required | Description | Default |
|---|---|---|---|
| search | No | Search query | |
| type | No | Security type | |
| market | No | Market type | |
| limit | No | Number of results (default: 100) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. 'Search/list' implies a read operation, but the description doesn't specify whether this is a filtered search, what the return format looks like, pagination behavior, rate limits, or authentication requirements. For a search tool with zero annotation coverage, this leaves significant behavioral gaps.
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 extremely concise at just three words, making it front-loaded and efficient. However, this conciseness comes at the cost of completeness - it's arguably under-specified rather than optimally concise. The single phrase communicates the core function without wasted words, but could benefit from additional context.
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 search tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'available tickers' means, how results are returned, what format they're in, or how this tool relates to the seven sibling tools. The agent lacks sufficient context to understand the tool's full behavior and appropriate usage scenarios.
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 all parameters are documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema. It doesn't explain how the search parameter works, what the type/market enums represent, or how the limit parameter affects results. The baseline score of 3 reflects adequate schema coverage without description enhancement.
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 'Search/list available tickers' states the basic purpose (searching/listing tickers) but is vague about scope and differentiation. It doesn't specify what constitutes 'available' tickers or how this differs from sibling tools like get_ticker_details or get_snapshot. The description provides a minimal viable purpose statement without clear distinction from 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 versus the seven sibling tools. There's no mention of alternatives like get_ticker_details for specific ticker information or get_aggregates for aggregated data. The agent must infer usage from the tool name alone, which is insufficient for informed tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Every tool has a clearly distinct purpose focused on different aspects of market data retrieval. Tools like get_aggregates (historical bars), get_daily_open_close (daily prices), get_latest_quote (real-time quote), and get_snapshot (current state) all serve unique functions without overlap, making it easy for an agent to select the right tool.
All tools follow a consistent verb_noun pattern with 'get_' or 'list_' prefixes, using snake_case throughout. This predictability (e.g., get_aggregates, list_tickers) makes the tool set easy to navigate and understand at a glance.
With 8 tools, this server is well-scoped for a financial market data domain, covering essential operations like real-time quotes, historical data, news, and ticker listings. Each tool earns its place without feeling excessive or insufficient for the purpose.
The tool set provides comprehensive coverage for market data retrieval, including real-time, historical, and informational aspects. A minor gap exists in lacking update/delete operations, but this is appropriate for a read-only data source, and agents can work around this limitation effectively.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
A Model Context Protocol (MCP) server for Selise Blocks Cloud integration
A Model Context Protocol server for Wix AI tools
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jwaresolutions/polygon-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
