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., "@TradeStation MCP Server get a quote for AAPL"
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 TradeStation API integration for Claude Code and other MCP clients.
Real-time market data (quotes, bars, option chains)
Account information (balances, positions, orders)
Order preview and validation
Automatic token refresh management
Support for both simulation and live environments
Related MCP server: MetaTrader5 MCP Server
marketData - Get real-time quotes for symbols
barChart - Get historical price bars/candles
getSymbolDetails - Get detailed symbol information
getOptionExpirations - Get available option expiration dates
getOptionStrikes - Get available option strike prices
getAccounts - List all brokerage accounts
getBalances - Get account balances and buying power
getPositions - Get current positions with P&L
getOrders - Get order history with optional status filter
getOrderDetails - Get detailed information for a specific order
getExecutions - Get fills/executions for a specific order
confirmOrder - Preview order costs and requirements (READ-ONLY, does not execute trades)
Node.js 18 or higher
TradeStation developer account with API credentials
Active TradeStation account (simulation or live)
Clone this repository:
git clone <repository-url>
cd mcp-tradesationInstall dependencies:
npm installCopy the example environment file:
cp .env.example .envEdit .env and add your TradeStation API credentials:
TRADESTATION_CLIENT_ID=your_client_id_here
TRADESTATION_CLIENT_SECRET=your_client_secret_here
TRADESTATION_REFRESH_TOKEN=your_refresh_token_here
TRADESTATION_REDIRECT_URI=http://localhost:3000/callbackBuild the server:
npm run buildCreate a new application to get your Client ID and Client Secret
Complete the OAuth flow to obtain a refresh token
Add the credentials to your .env file
Add the following to your Claude Code MCP configuration file:
macOS/Linux: ~/.config/claude-code/mcp_config.json
Windows: %APPDATA%\claude-code\mcp_config.json
{
"mcpServers": {
"tradestation": {
"command": "node",
"args": ["/path/to/mcp-tradesation/build/index.js"],
"env": {
"TRADESTATION_CLIENT_ID": "your_client_id_here",
"TRADESTATION_CLIENT_SECRET": "your_client_secret_here",
"TRADESTATION_REFRESH_TOKEN": "your_refresh_token_here",
"TRADESTATION_REDIRECT_URI": "http://localhost:3000/callback"
}
}
}
}Alternatively, if you have a .env file in the project directory, you can omit the env section and the server will automatically load credentials from the .env file.
Once configured, the MCP tools will be automatically available in Claude Code. You can use them like this:
Get a quote for SPY
Show me a 5-minute chart for AAPL with the last 20 bars
What are my account balances?
List my current positions
Preview an order to buy 100 shares of SPY at market pricemcp-tradesation/
├── src/
│ ├── index.ts # Main MCP server implementation
│ └── test-*.js # Test scripts for API endpoints
├── build/ # Compiled JavaScript output
├── .env.example # Example environment configuration
├── package.json # Package dependencies and scripts
└── tsconfig.json # TypeScript configurationThe project includes several test scripts to verify API functionality:
# Test token refresh and basic API access
node src/quick-token-test.js
# Test all MCP server functions
node src/test-mcp-functions.js
# Test specific endpoints
node src/test-specific-endpoints.jsnpm run buildThis compiles the TypeScript source to JavaScript in the build/ directory.
Variable | Required | Description |
| Yes | Your TradeStation API client ID |
| Yes | Your TradeStation API client secret |
| Yes | OAuth refresh token for authentication |
| Yes | OAuth redirect URI (must match app config) |
| No | Default account ID for operations |
| No | Environment: 'simulation' or 'production' (default: simulation) |
If you see authentication errors:
Verify your credentials in the .env file are correct
Ensure your refresh token hasn't expired
Check that your TradeStation account has API access enabled
If the build fails:
Ensure you have Node.js 18 or higher installed
Delete node_modules and build directories
Run npm install again
Run npm run build
If Claude Code can't connect to the server:
Verify the path to build/index.js in your MCP config is correct
Check that the server built successfully (build/index.js exists)
Review Claude Code logs for error messages
For detailed TradeStation API documentation, visit:
ISC
Contributions are welcome! Please feel free to submit issues or pull requests.
Get historical price bars/candles
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Trading symbol | |
| interval | Yes | Bar interval value (e.g., 1, 5, 15) | |
| unit | Yes | Bar interval unit | |
| beginTime | No | Begin time in ISO format (optional) | |
| endTime | No | End time in ISO format (optional) | |
| barsBack | No | Number of bars to return (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. 'Get' implies a read operation, but the description doesn't mention rate limits, authentication requirements, data freshness, or what happens when optional parameters are omitted. This leaves significant gaps for a tool with 6 parameters.
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 immediately communicates the core functionality. There's no wasted language or unnecessary elaboration, making it optimally concise while still being informative.
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 with 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the returned data looks like, how bars/candles are structured, or provide any context about data sources, limitations, or typical use cases. The agent would need to guess about important behavioral aspects.
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%, providing complete parameter documentation. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't enhance understanding of parameter usage or relationships.
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 ('historical price bars/candles'), making the tool's purpose immediately understandable. However, it doesn't differentiate itself from potential siblings like 'marketData' or other data retrieval tools, 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 'marketData' and 'getSymbolDetails' available, there's no indication of what makes this tool distinct or when it should be preferred over other data retrieval methods.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Preview order costs and requirements (READ-ONLY - does not execute trades)
| Name | Required | Description | Default |
|---|---|---|---|
| accountId | No | Account ID (optional, uses TRADESTATION_ACCOUNT_ID from env if not provided) | |
| symbol | Yes | Symbol to trade (e.g., SPY, SPY 251121C580) | |
| quantity | Yes | Order quantity | |
| orderType | Yes | Order type | |
| tradeAction | Yes | Trade action | |
| limitPrice | No | Limit price (required for Limit and StopLimit orders) | |
| stopPrice | No | Stop price (required for Stop and StopLimit orders) | |
| duration | No | Time in force duration | DAY |
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 clearly states the tool is 'READ-ONLY - does not execute trades,' which is crucial safety information. However, it doesn't mention rate limits, authentication requirements, or what specific 'costs and requirements' are returned in the preview.
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 (one sentence plus a parenthetical clarification) and front-loaded with the core purpose. Every word earns its place, with no wasted text or redundancy.
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 with 8 parameters, 100% schema coverage, and no output schema, the description provides adequate context about its read-only nature and purpose. However, it could be more complete by hinting at the return format (e.g., 'returns estimated costs and validation results') since there's no output schema.
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 all 8 parameters thoroughly with descriptions and enums. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score 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 states the specific action ('Preview order costs and requirements') and resource ('order'), with explicit distinction from actual execution ('READ-ONLY - does not execute trades'). This differentiates it from potential sibling tools that might execute trades.
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 clear context for when to use this tool ('Preview order costs and requirements'), implying it's for pre-trade analysis. However, it doesn't explicitly mention when not to use it or name specific alternatives among the sibling tools (like which tools would actually execute trades).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get list of brokerage accounts
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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. 'Get list' implies a read operation, but it doesn't specify whether this requires authentication, returns all accounts or a subset, includes pagination, or has rate limits. For a 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 a single, efficient sentence that directly states the tool's function without any fluff. It's perfectly front-loaded and every word earns its place, making it immediately clear what the tool does.
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 with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the return value looks like (e.g., account IDs, names, types), whether there are authentication requirements, or any behavioral constraints. Given the lack of structured data, the description should provide more 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 tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't waste space discussing parameters, maintaining focus on the tool's purpose. Baseline for 0 parameters is 4, as no parameter semantics are needed.
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 verb ('Get') and resource ('list of brokerage accounts'), making the purpose immediately understandable. It distinguishes from siblings like 'getBalances' or 'getPositions' by focusing specifically on account listing rather than financial data within accounts. However, it doesn't specify scope or filtering options, 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 'getBalances' or 'getPositions'. It doesn't mention prerequisites, context for usage, or any exclusions. The agent must infer usage purely from the tool name and sibling relationships.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get account balances and buying power
| Name | Required | Description | Default |
|---|---|---|---|
| accountId | No | Account ID (optional, uses TRADESTATION_ACCOUNT_ID from env if not provided) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, it doesn't specify whether this requires authentication, has rate limits, returns real-time or cached data, or what format the output takes. This leaves significant gaps for an agent to understand the tool's behavior.
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 5 words, front-loading the core purpose with zero wasted words. Every element ('Get', 'account balances', 'buying power') contributes directly to understanding the tool's function.
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 financial tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'balances' includes (cash, securities, margin), whether 'buying power' is real-time, what authentication is needed, or the response format. Given the complexity of financial data, this leaves too many unknowns for reliable agent use.
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%, with the single parameter 'accountId' fully documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema, so it meets the baseline expectation without providing extra value.
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 purpose with specific verbs ('Get') and resources ('account balances and buying power'), making it immediately understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'getAccounts' or 'getPositions', which might also provide related financial information.
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 sibling tools like 'getAccounts' and 'getPositions' available, there's no indication of whether this tool is for summary balances, real-time data, or how it differs from other financial query tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get fills/executions for a specific order
| Name | Required | Description | Default |
|---|---|---|---|
| accountId | No | Account ID (optional, uses TRADESTATION_ACCOUNT_ID from env if not provided) | |
| orderId | Yes | Order ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions retrieving data but fails to specify if this is a read-only operation, requires authentication, has rate limits, or returns paginated results. For a data retrieval tool with zero annotation coverage, this leaves critical behavioral traits unexplained.
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 directly states the tool's function without any unnecessary words. It is front-loaded with the core action and resource, 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 the lack of annotations and output schema, the description is insufficient for a tool that retrieves data. It does not explain the return format (e.g., list of executions, error handling), authentication needs, or how it differs from sibling tools, leaving gaps in understanding its 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?
Schema description coverage is 100%, so the input schema fully documents the parameters (accountId and orderId). The description adds no additional meaning beyond implying that 'orderId' is used to fetch executions, which is already clear from the schema. This 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 verb ('Get') and resource ('fills/executions for a specific order'), making the purpose unambiguous. However, it does not differentiate this tool from potential siblings like 'getOrderDetails' or 'getOrders', which might also retrieve order-related data, leaving room for ambiguity in tool selection.
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 such as 'getOrderDetails' and 'getOrders' available, there is no indication of whether this tool is for detailed execution data versus summary order information, leading to potential misuse without additional context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get available expiration dates for options on an underlying symbol
| Name | Required | Description | Default |
|---|---|---|---|
| underlying | Yes | Underlying symbol (e.g., AAPL, SPY) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states what the tool does without behavioral details. It doesn't disclose whether this is a read-only operation, potential rate limits, authentication needs, or what the return format looks like, leaving significant 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 a single, efficient sentence that directly states the tool's function with zero wasted words. It's appropriately sized and front-loaded, 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 the lack of annotations and output schema, the description is incomplete for a tool that likely returns structured data. It doesn't explain what 'available expiration dates' means in practice (e.g., date format, range, or filtering), leaving the agent with insufficient context for effective use.
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 'underlying' well-documented in the schema. The description adds no additional parameter semantics beyond implying it's for options, so it meets the baseline for high schema coverage without compensating value.
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 available expiration dates') and the resource ('options on an underlying symbol'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'getOptionStrikes' which likely retrieves different option data, missing explicit distinction.
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 'getOptionStrikes' or 'getSymbolDetails', nor does it mention prerequisites or exclusions. It implies usage for options data but lacks contextual boundaries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get available strike prices for options on an underlying symbol
| Name | Required | Description | Default |
|---|---|---|---|
| underlying | Yes | Underlying symbol (e.g., AAPL, SPY) | |
| expiration | No | Expiration date filter in YYYY-MM-DD format (optional) |
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 lacks details on permissions, rate limits, response format, or error handling. For a tool with zero annotation coverage, this is a significant gap in 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 a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy to understand at a glance.
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 the return values look like (e.g., list of strikes, format), error conditions, or behavioral traits, which are crucial for a tool with no structured data to compensate.
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 schema already documents both parameters ('underlying' and 'expiration') with clear descriptions. The description implies these parameters but adds no additional meaning beyond what the schema provides, meeting the baseline for 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 clearly states the verb ('Get') and resource ('available strike prices for options on an underlying symbol'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'getOptionExpirations' or 'getSymbolDetails', which could provide related information, 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. It doesn't mention sibling tools like 'getOptionExpirations' for expiration dates or 'searchSymbols' for symbol lookup, nor does it specify prerequisites or exclusions, leaving usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information for a specific order
| Name | Required | Description | Default |
|---|---|---|---|
| accountId | No | Account ID (optional, uses TRADESTATION_ACCOUNT_ID from env if not provided) | |
| orderId | Yes | Order ID |
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. It states this is a 'Get' operation, implying read-only behavior, but doesn't clarify authentication requirements, rate limits, error conditions, or what 'detailed information' includes (e.g., order status, timestamps, or financial details). This leaves significant gaps for an agent to understand the tool's behavior.
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. It's front-loaded with the core purpose and efficiently communicates the essential action 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?
For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'detailed information' includes, how results are structured, or potential limitations. Given the context of financial trading (inferred from sibling tools), more detail on return values like order status, quantities, or prices would be helpful 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?
The description doesn't add any parameter-specific information beyond what's already in the schema (which has 100% coverage). It doesn't explain the relationship between 'accountId' and 'orderId', or provide examples of valid order IDs. Since the schema fully documents both parameters, the 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 verb ('Get') and resource ('detailed information for a specific order'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'getOrders' (which likely lists multiple orders) or 'getExecutions' (which might show order executions), leaving room for potential confusion.
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. It doesn't mention sibling tools like 'getOrders' for listing orders or 'getExecutions' for order execution details, nor does it specify prerequisites or contextual constraints beyond needing an order ID.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get order history with optional status filter
| Name | Required | Description | Default |
|---|---|---|---|
| accountId | No | Account ID (optional, uses TRADESTATION_ACCOUNT_ID from env if not provided) | |
| status | No | Filter orders by status | All |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the basic function. It doesn't disclose important behavioral traits like whether this is a read-only operation, if it requires authentication, rate limits, pagination behavior, or what format the order history returns. The description is minimal and lacks necessary context for safe invocation.
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 for a simple retrieval tool and front-loads the core purpose immediately.
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 retrieves potentially sensitive order data. It should explain what information is returned, any authentication requirements, and behavioral constraints. The current description provides only basic functional intent without necessary operational 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?
Schema description coverage is 100%, so the schema already fully documents both parameters. The description mentions 'optional status filter' which aligns with the schema's status parameter, but adds no additional semantic context beyond what the schema provides. Baseline 3 is appropriate when 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 verb 'Get' and resource 'order history' with the specific capability of 'optional status filter'. It distinguishes from sibling tools like getOrderDetails (specific order) and getExecutions (filled trades), but doesn't explicitly mention these distinctions in the description itself.
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 retrieving order history with optional filtering, but doesn't provide explicit guidance on when to use this vs. alternatives like getOrderDetails (for specific orders) or getExecutions (for filled trades). No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current positions with P&L
| Name | Required | Description | Default |
|---|---|---|---|
| accountId | No | Account ID (optional, uses TRADESTATION_ACCOUNT_ID from env if not provided) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'Get current positions with P&L', which implies a read-only operation, but doesn't specify data freshness (e.g., real-time vs. cached), authentication needs, rate limits, or error handling. For a financial tool with no annotation coverage, this is a significant gap in 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 a single, efficient sentence with no wasted words, clearly stating the tool's purpose. 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 complexity of financial data retrieval and the lack of annotations and output schema, the description is insufficient. It doesn't explain what 'P&L' entails (e.g., unrealized vs. realized), the format of returned positions, or any prerequisites like account setup. For a tool in this context, more detail is needed to ensure proper 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 input schema has 100% description coverage, with the single parameter 'accountId' well-documented in the schema. The description doesn't add any parameter-specific details beyond what the schema provides, such as clarifying what 'P&L' includes or default behaviors. Baseline 3 is appropriate since the schema handles the parameter documentation adequately.
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 verb 'Get' and the resource 'current positions with P&L', making the purpose evident. However, it doesn't distinguish this tool from potential siblings like 'getBalances' or 'getOrders', which might also retrieve financial data, leaving room for ambiguity in a trading context.
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. In a server with multiple financial tools like 'getBalances' or 'getOrders', there's no indication of whether this is for real-time positions, historical data, or specific account types, making it unclear when this is the appropriate choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed symbol information
| Name | Required | Description | Default |
|---|---|---|---|
| symbols | Yes | Single symbol or comma-separated list of symbols |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get detailed symbol information' but doesn't clarify if this is a read-only operation, requires authentication, has rate limits, or what the output format might be. For a tool with no annotations, this leaves significant gaps in understanding its behavior and constraints.
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: 'Get detailed symbol information'. It's front-loaded with the core action and resource, with zero wasted words. Every part of the sentence contributes directly to the tool's purpose, making it highly concise 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?
Given the lack of annotations and output schema, the description is incomplete for a tool that likely returns complex data (implied by 'detailed'). It doesn't address what 'detailed' includes, error handling, or response structure. With no structured fields to compensate, the description should provide more context to be fully helpful.
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, with the 'symbols' parameter clearly documented as a 'Single symbol or comma-separated list of symbols'. The description adds no additional meaning beyond this, as it doesn't elaborate on symbol formats, examples, or constraints. With high schema coverage, the 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 'Get detailed symbol information' states a clear verb ('Get') and resource ('symbol information'), but it's vague about what constitutes 'detailed' information. It doesn't distinguish this tool from sibling tools like 'searchSymbols' or 'marketData', which might also provide symbol-related data. The purpose is understandable but lacks specificity.
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 'searchSymbols' and 'marketData' available, there's no indication of whether this tool is for lookup, search, or real-time data, nor any prerequisites or exclusions mentioned. Usage is implied but not explicitly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get quotes for symbols
| Name | Required | Description | Default |
|---|---|---|---|
| symbols | Yes | Comma-separated list of symbols |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get quotes for symbols' implies a read-only operation, but it doesn't specify any behavioral traits like rate limits, authentication needs, data freshness, or potential costs. The description is minimal and fails to provide necessary context for safe and effective use.
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 just four words, front-loaded and to the point. There is no wasted language or unnecessary elaboration, making it efficient for quick understanding. Every word contributes directly to stating the tool's purpose.
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 for effective use. It doesn't cover behavioral aspects like data sources, latency, or error handling, and with no output schema, it fails to hint at return values. For a tool that likely involves external data fetching, this leaves significant gaps in understanding its operation and results.
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, with the 'symbols' parameter documented as a 'Comma-separated list of symbols'. The description adds no additional meaning beyond this, as it doesn't explain format examples, symbol types, or constraints. Given the high schema coverage, a baseline score of 3 is appropriate, as the schema handles the parameter documentation adequately.
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 quotes for symbols' clearly states the verb ('Get') and resource ('quotes for symbols'), making the purpose understandable. However, it lacks specificity about what type of quotes (e.g., real-time, delayed, market data) and doesn't differentiate from sibling tools like 'getSymbolDetails' or 'searchSymbols', which might provide related information. It avoids tautology but remains somewhat vague.
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. It doesn't mention any context, prerequisites, or exclusions, such as whether it's for real-time data, historical data, or how it differs from siblings like 'getSymbolDetails' or 'searchSymbols'. This leaves the agent without clear direction on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for symbols (Note: Symbol search not available in TradeStation v3 API - use getSymbolDetails instead with known symbols)
| Name | Required | Description | Default |
|---|---|---|---|
| criteria | Yes | Search criteria | |
| type | No | Symbol type filter | all |
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 discloses a critical behavioral trait: that symbol search is not available in TradeStation v3 API, which is essential context beyond what the input schema provides. However, it doesn't mention other potential behaviors like rate limits, authentication needs, or what happens when the search fails, leaving some 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 and front-loaded, consisting of just two sentences that directly address the tool's purpose and critical usage limitation. Every sentence earns its place by providing essential information without any 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 complexity (search functionality with API limitations), no annotations, and no output schema, the description is mostly complete. It covers the purpose, usage guidelines, and a key behavioral limitation. However, it lacks details on what the search returns (e.g., format, pagination) or error handling, which would be helpful for full completeness.
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 both parameters ('criteria' and 'type') with descriptions and enum values. The description does not add any additional meaning or context about the parameters beyond what the schema provides, so it meets 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 states the tool's purpose with a specific verb ('Search for symbols') and resource ('symbols'), and explicitly distinguishes it from the sibling tool 'getSymbolDetails' by noting that symbol search is not available in TradeStation v3 API and to use getSymbolDetails instead with known symbols. This provides clear differentiation 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 explicit guidance on when to use this tool vs. alternatives by stating 'Symbol search not available in TradeStation v3 API - use getSymbolDetails instead with known symbols.' This clearly indicates when not to use this tool and names the alternative, offering complete usage context.
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.
v1.0.0barChart2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falseconfirmOrder2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetAccounts1 field changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"getBalances2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetExecutions2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetOptionExpirations2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetOptionStrikes2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetOrderDetails2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetOrders2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetPositions2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsegetSymbolDetails2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsemarketData2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsesearchSymbols2 fields changedInput schema / $schemaAdded value: +"http://json-schema.org/draft-07/schema#"Input schema / additionalPropertiesAdded value: +falsebarChartconfirmOrdergetAccountsgetBalancesgetExecutionsgetOptionExpirationsgetOptionStrikesgetOrderDetailsgetOrdersgetPositionsgetSymbolDetailsmarketDatasearchSymbolsScored across 13 tools
Most tools have distinct purposes, such as getAccounts for account lists and getBalances for balances, but there is some overlap between getOrders and getOrderDetails, and between marketData and barChart for price data, which could cause minor confusion.
The naming follows a consistent verb_noun pattern with minor deviations, as most tools start with 'get' or descriptive verbs like 'confirm' and 'search', but 'barChart' and 'marketData' break this pattern slightly by using noun-based names.
With 13 tools, the count is well-scoped for a brokerage and trading server, covering key areas like accounts, orders, market data, and options without being overwhelming or insufficient.
The toolset provides comprehensive coverage for querying accounts, orders, positions, and market data, but lacks tools for executing trades or modifying orders, which are notable gaps in a trading context.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Tradier MCP — stock & options market data via the Tradier Brokerage API
Real-time market data, screeners, technical analysis & backtesting for stocks, crypto and forex.
Hosted MCP for stocks, options, Greeks, brokers, order previews, alerts, and workflows.
Trade across 22+ exchanges and brokers from any MCP-capable AI agent, no install required.
