Dataline MCP Server
OfficialThe Dataline MCP server provides read-only access to crypto market data, blockchain project fundamentals, exchange announcements, and prediction market data from platforms like Polymarket and Kalshi.
Crypto Market Data
get_price: Spot price for any base/quote pair (e.g., BTC/USDT) across multiple exchanges with an aggregated average.get_funding_rate: Annualized funding rates for perpetual futures contracts on Binance, Bybit, and OKX.get_project_detail: Fundamentals, market metrics, exchange presence, investors, and funding rounds for blockchain projects.
Exchange Announcements
get_exchange_announcement_categories: List normalized announcement categories.get_exchange_announcement_list: Search/list announcements with pagination.get_exchange_announcement_detail: Full details of a single announcement.
Prediction Markets
get_odds_categories: List available event categories (crypto, politics, sports, etc.).get_odds_event_list: Browse events filterable by category, platform, status, and sort order.search_prediction_events: Full-text search across prediction events by keyword, slug, or ticker.get_prediction_event_detail: Full details for a single event including sub-markets, outcome probabilities, rules, and settlement timing.get_odds_event_orderbook: Raw bid/ask orderbook for a specific prediction market outcome.get_prediction_market_quote: Best bid/ask, mid price, spread, and implied probability for a given market outcome.
All tools are read-only and require a Dataline API key with HMAC signing. The server works with any MCP client (Claude Desktop, Cursor, Continue, custom agents).
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., "@Dataline MCP Serverwhat's the current price of BTC in USDT?"
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.
@dataline-xyz/dataline-mcp
A Model Context Protocol (MCP) server and TypeScript SDK for the Dataline data API.
It exposes a focused set of read-only market-data tools to MCP-compatible clients (Claude Desktop, Cursor, Continue, custom agents, etc.):
Spot and perpetual prices for crypto assets
Perpetual funding rates (annualized)
Blockchain project details by token symbol/name or contract address
Exchange announcements, categories, search/list, and full details
Prediction-market categories, events, search, details, orderbook
Best-quote helper that aggregates the orderbook into a single number
Install
Using npx (no install required):
npx -y @dataline-xyz/dataline-mcpOr install globally:
npm install -g @dataline-xyz/dataline-mcp
dataline-mcpRelated MCP server: 0xarchive-mcp
Configure
The server reads credentials from environment variables:
Variable | Required | Default | Description |
| yes | — | API key issued by Dataline |
| yes | — | Secret used to sign requests (HMAC-SHA256) |
| no |
| Override the API base URL |
| no |
| Per-request timeout in milliseconds |
See .env.example for a copy/pastable template.
Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):
{
"mcpServers": {
"dataline": {
"command": "npx",
"args": ["-y", "@dataline-xyz/dataline-mcp"],
"env": {
"DATALINE_API_KEY": "your_api_key_here",
"DATALINE_SECRET_KEY": "your_secret_key_here"
}
}
}
}Cursor / Continue / other MCP clients
Use the same command + env mapping in your client's MCP configuration.
Tools
Tool | Purpose |
| Spot or swap price for a base/quote pair |
| Annualized funding rate for a perpetual contract |
| Project fundamentals, market metrics, exchange presence, investors, and funding rounds |
| List normalized exchange announcement categories |
| Search/list exchange announcements (paginated) |
| Full detail for a single exchange announcement |
| List prediction-market event categories |
| List prediction-market events (paginated) |
| Full-text search across prediction events |
| Full detail for a single prediction event |
| Orderbook (bids/asks) for a specific outcome market |
| Convenience helper: best bid/ask + mid from the orderbook |
SDK usage
import { DatalineClient } from "@dataline-xyz/dataline-mcp";
const client = new DatalineClient({
apiKey: process.env.DATALINE_API_KEY!,
secretKey: process.env.DATALINE_SECRET_KEY!,
});
const price = await client.getPrice({ base_currency: "BTC", quote_currency: "USDT" });
console.log(price);Development
pnpm install
pnpm build
pnpm testThe OpenAPI spec for the supported endpoints ships as openapi.json next to this README.
License
Available Tools
8 toolsget_funding_rateA
Get current funding rate for a perpetual futures contract. Returns per-venue funding rates with annualized rates and next funding timestamps. Supported venues: binance, bybit, okx.
| Name | Required | Description | Default |
|---|---|---|---|
| base_currency | Yes | Crypto ticker symbol, e.g. BTC, ETH | |
| quote_currency | No | Quote currency filter |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, description covers return structure (per-venue rates, annualized rates, next funding timestamps) but omits behavioral details such as read-only nature, error handling, or rate limits.
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?
Two concise sentences efficiently convey purpose and venue list without redundant text, but could be more front-loaded with key verb and resource.
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?
Though no output schema, description adequately explains return fields given simplicity of the tool; could be improved by hinting at JSON structure or error cases.
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 examples for base_currency; description does not add additional semantic meaning beyond the schema, so 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 states 'Get current funding rate for a perpetual futures contract' with specific verb and resource, lists supported venues, and clearly differentiates from sibling tools like 'get_price' which focuses on spot prices.
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 implies usage for funding rates and lists venues, but does not provide explicit when-to-use or when-not-to-use guidance, nor does it reference alternative tools for related data like spot prices.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_odds_categoriesA
List all available prediction market event categories (e.g. crypto, politics, sports). Returns an array of category name strings. Use these values as the category filter in get_odds_event_list. No parameters required.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully discloses the tool's behavior: it lists categories, returns a string array, and requires no parameters. There are no hidden or unexpected side effects, and the description is honest and complete.
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 two sentences, no wasted words. It is front-loaded with the main purpose and immediately provides return type and usage hint. 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?
Given the tool's simplicity, no output schema, and no parameters, the description covers all necessary aspects: what it does, what it returns, and how to use the result. It is complete and leaves no ambiguity.
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 no parameters, and the description correctly states 'No parameters required,' adding clarity beyond the schema. The description ensures the agent knows no input is needed, which is valuable.
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 lists all available prediction market event categories, provides examples (crypto, politics, sports), and specifies the return type (array of category name strings). It effectively distinguishes from sibling tools like get_odds_event_list which uses these categories as a filter.
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 the agent to use the returned category values in the 'get_odds_event_list' tool, providing clear downstream usage context. However, it does not mention when not to use this tool or suggest alternatives, though alternatives may not be necessary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_odds_event_listA
List prediction market events, optionally filtered by category, platform, and status. Returns events with markets and outcome probabilities. Use get_odds_categories to discover valid category values. Limit max 50 per page.
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Category filter e.g. crypto, politics, sports. Use get_odds_categories to list valid values. | |
| status | No | Filter by event status. Default 'open'. | open |
| sort | No | Sort order | volume |
| page | No | Page number for pagination | |
| limit | No | Results per page (max 50) | |
| platform | No | Platform filter | |
| cursor | No | Cursor for next page pagination. Pass the cursor value from a previous response. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It states what the tool returns (events with markets and outcome probabilities) and implies pagination via the limit note, but it omits details about sorting, cursor usage, data freshness, or any potential side effects. The tool is likely read-only, but this is not explicitly stated.
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 at two sentences, front-loading the core action and key parameters, 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?
Given the lack of an output schema, the description sufficiently explains the return type. It covers pagination constraints but does not detail cursor usage for pagination, which is partially addressed by the schema. Overall, it provides adequate context for a list tool with multiple optional filters.
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%, providing baseline 3. The description adds value by directing users to a sibling tool for valid category values and reinforcing the limit constraint. This extra context justifies a score above baseline.
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 lists prediction market events, with optional filters by category, platform, and status. It mentions the return type (events with markets and outcome probabilities) and directs users to a sibling tool for category values, aiding differentiation.
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 to use get_odds_categories for valid category values and notes the maximum limit of 50 per page. However, it does not specify when to use alternative sibling tools like get_prediction_event_detail for more detailed event information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_odds_event_orderbookA
Get the raw orderbook (bids and asks) for a specific prediction market outcome. Provide either kalshi_market_id OR polymarket_market_id (not both, at least one required). Returns raw bid/ask levels — use the best bid and ask to compute mid price and implied probability.
| Name | Required | Description | Default |
|---|---|---|---|
| kalshi_market_id | No | Kalshi market identifier | |
| polymarket_market_id | No | Polymarket market ID (condition ID or token ID) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description clearly indicates a read operation and specifies that it returns raw bid/ask levels. It adds context on how to use the output (compute mid price). No contradictions present.
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?
Two sentences: first states purpose, second gives parameter usage and output. No fluff, 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 no output schema, the description covers required parameters and output nature. It lacks details on bid/ask structure but is sufficient for a simple retrieval tool.
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?
Schemas already describe parameters (100% coverage). The description adds the mutual exclusivity constraint and requirement, which is valuable 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?
The description clearly states 'Get the raw orderbook (bids and asks)' with a specific resource 'for a specific prediction market outcome', distinguishing it from sibling tools like get_price or get_prediction_market_quote.
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 that either kalshi_market_id or polymarket_market_id is required but not both, providing clear usage constraint. However, it does not contrast with sibling tools or suggest when to use orderbook vs price/quote.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_prediction_event_detailA
Get full details for one prediction market event: sub-markets, outcome probabilities, rules summary, and settlement timing. WARNING: large events (e.g. election brackets) can have 100+ sub-markets and return very large responses. Default markets_limit is 20. Increase only when you need full coverage.
| Name | Required | Description | Default |
|---|---|---|---|
| provider | Yes | Platform the event is on | |
| event_id | Yes | Event ID from search results | |
| markets_limit | No | Max number of sub-markets to include (default 20). Large events have 100+ markets. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses that large events can have 100+ sub-markets and return large responses. Does not mention authentication or rate limits, but the behavioral trait of response size is clearly communicated.
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?
Two sentences: first states purpose, second warns about large events and parameter usage. No filler, every sentence adds essential 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?
No output schema, but description lists return elements (sub-markets, probabilities, rules, settlement timing). Adequately covers input parameters with warning. Could mention error handling, but sufficient for tool selection.
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% description coverage. Description adds value beyond schema by explaining the warning about large events and advising on markets_limit usage ('Increase only when you need full 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?
Clearly states 'Get full details for one prediction market event' with specifics (sub-markets, outcome probabilities, rules summary, settlement timing). Distinguishes from sibling tools like search_prediction_events and get_prediction_market_quote.
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?
Provides explicit warning about large events and guidance on markets_limit default and adjustment. Lacks explicit when-not-to-use or alternatives, but warning implies cautious usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_prediction_market_quoteA
Get a quote for a prediction market outcome computed from live orderbook data. Returns best bid, best ask, mid price, spread, and implied probability percentage. Outcome must be 'yes' or 'no'. Use market_id from get_prediction_event_detail results.
| Name | Required | Description | Default |
|---|---|---|---|
| platform | Yes | Prediction market platform | |
| market_id | Yes | Market ID from event detail results | |
| outcome | Yes | Outcome side to quote: 'yes' or 'no' | |
| side | No | Trade direction | buy |
| quote_notional | No | Optional: trade size in USD for execution simulation | |
| depth | No | Orderbook depth levels to use (1-20) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description alone must convey behavior. It correctly indicates that data is from live orderbook data and lists return fields. However, it does not disclose whether the operation is read-only, any rate limits, or potential side effects. While adequate, it lacks depth on behavioral traits.
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 very concise: three sentences that sequentially cover purpose with return values, constraint on outcome, and sourcing of market_id. It is front-loaded and 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?
Given 6 parameters (all documented in schema) and no output schema, the description adequately explains the return format (fields). It does not cover error scenarios or rate limits, but for a quote tool with moderate complexity, 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 description coverage is 100%, so baseline is 3. The description adds context for market_id (source from get_prediction_event_detail) and implies that parameters like side and depth affect the quote. However, it does not elaborate on parameter specifics beyond the schema's own descriptions.
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 purpose: getting a quote for a prediction market outcome from live orderbook data. It specifies the return values (best bid, best ask, mid price, spread, implied probability) and constraints (outcome must be 'yes' or 'no'). This distinguishes it from siblings like get_price, which may return only a simple price.
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 guidance on outcome constraint and sourcing market_id from another tool. However, it does not explicitly state when to use this tool versus alternatives like get_price or get_odds_event_orderbook, nor does it mention 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.
get_priceA
Get current spot price for a crypto asset. Provide base_currency (e.g. BTC) and optional quote_currency (default USDT). Returns per-source prices from multiple exchanges and an average. For perpetual futures data (funding rates), use get_funding_rate instead.
| Name | Required | Description | Default |
|---|---|---|---|
| base_currency | Yes | Base currency ticker, e.g. BTC, ETH, SOL | |
| quote_currency | No | Quote currency, e.g. USDT. Defaults to exchange default. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It states that the tool 'Returns per-source prices from multiple exchanges and an average', which gives insight into the output structure. It does not mention rate limits or authentication, but for a simple price tool, this is sufficient.
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 three sentences long, front-loading the purpose, and every sentence adds value (purpose, parameter hint, sibling distinction). 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 simplicity (2 params, no output schema), the description covers all necessary aspects: what it does, how to use parameters, what the output contains, and when not to use it (via sibling reference). It is complete for this use case.
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 the parameters. The description adds minor context (e.g., default quote_currency is USDT, examples like BTC, ETH, SOL) but does not significantly enhance 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 'Get current spot price for a crypto asset', specifying the verb (get) and resource (spot price). It distinguishes from the sibling tool get_funding_rate by explicitly noting that for perpetual futures data, that tool should be used.
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 when to use this tool (for spot price) and provides an alternative for a different use case (get_funding_rate for perpetual futures). It also explains the required and optional parameters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_prediction_eventsA
Search prediction market events by keyword, slug, or ticker-like text on Polymarket and Kalshi. Returns matching events with markets and outcome probabilities. Query must be at least 3 characters. Use get_odds_event_list to browse without a keyword.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search keyword, slug, or ticker. Min 3 characters. | |
| status | No | Filter by event status. Default 'open' — use 'all' only when you need historical events. | open |
| sort | No | Sort order for results | relevance |
| page | No | Page number for pagination | |
| limit | No | Results per page |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It implies read-only search behavior, mentions output contains events/markets/probabilities. Could explicitly state non-destructive nature but sufficient.
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 concise sentences, front-loaded with action, no wasted words. Includes essential constraint and sibling tool reference.
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?
Describes inputs, output, and constraint. With 5 parameters all well-described in schema, and no output schema needed, description is nearly complete. Could mention pagination explicitly but minor.
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 3. Description adds search context but no new parameter semantics beyond schema. Adequate.
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?
Clearly states the tool searches prediction market events by keyword, slug, or ticker on Polymarket and Kalshi. Returns matching events with markets and outcome probabilities. Distinguishes from sibling get_odds_event_list.
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?
Explicitly says to use get_odds_event_list for browsing without a keyword. Also mentions query length minimum. Schema further specifies default status and enum options.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Tools are clearly separated into crypto (get_funding_rate, get_price) and prediction markets (the rest). Within each group, each tool has a distinct purpose with no overlap.
All tools follow a consistent verb_noun pattern using snake_case (e.g., get_funding_rate, get_odds_event_list), making the set predictable and easy to navigate.
With 8 tools covering two domains, the count is reasonable. The crypto side has only 2 tools, which feels slightly thin, but the prediction market side is well-scoped with 6 tools.
The prediction market tools cover browsing, searching, and quoting data, missing only order placement (likely out of scope). Crypto tools cover spot and funding rates but lack history or orderbook data. Minor gaps, but the set is functional for data retrieval.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Read-only MCP server for The Quiet Protocol's engines, benchmarks, proof, and business data.
33 pay-per-call market and news data tools over MCP with free discovery and x402 payments.
Real-time crypto market data: candles, tickers, orderbooks across 13+ exchanges via MCP.
Unlock the power of real-time cryptocurrency data with our Crypto Price Insights MCP server.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server that provides structured access to Aster DEX market data—covering candlesticks, order books, trades, and funding rates.115MIT
- AlicenseAqualityFmaintenanceMCP server for querying historical and real-time crypto market data across Hyperliquid, Hyperliquid HIP-3, and Lighter.xyz - orderbooks, trades, candles, funding, open interest, liquidations, and data quality metrics.1002711MIT
- AlicenseNot gradedqualityBmaintenanceA read-only MCP server for Hyperliquid that provides public market data (prices, order books, funding) and any wallet's positions, orders, and fills via MCP tools, without requiring a private key.MIT
- AlicenseAqualityBmaintenanceA read-only MCP server for querying Hyperliquid perp markets, funding rates, order books, candles, and account positions/fills/funding for any address, without needing API keys or wallets.8551MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/dataline-xyz/dataline-mcps'
If you have feedback or need assistance with the MCP directory API, please join our Discord server