Paradex MCP Server
The Paradex MCP Server lets AI assistants interact with Paradex for market data, account monitoring, trading, and vault operations.
Query system config/state and market data: markets, summaries, funding rates, order books, klines, trades, and BBO.
Inspect accounts: summaries, balances, positions, fills, funding payments, transactions, keys/tokens, profile, and consolidated overview.
Validate trades before execution with pre-trade checks, fees, slippage, funding, and readiness estimates.
Trade: create, cancel, list, and check orders; review order history/status.
Monitor vaults: details, balances, summaries, transfers, positions, account summaries, and vault overview.
Generate Paradex subkeys for agent trading.
Use prompts for market analysis, portfolio/position management, hedging, liquidation protection, vault analysis, funding arbitrage, and trading consultation.
Connect via stdio, Docker, or HTTP/AWS Lambda, with optional Paradex documentation MCP access.
Click on "Deploy 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., "@Paradex MCP Server show my current positions and account balance"
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.
MCP Paradex Server
Model Context Protocol (MCP) server implementation for the Paradex trading platform.
Quickstart
New here? See the Quickstart Guide for step-by-step setup instructions for Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Claude.ai web, and ChatGPT.
Need a remote HTTP endpoint for ChatGPT or Claude.ai web? See the HTTP Deployment Guide for Railway, Render, Fly.io, AWS Lambda, and Docker/VPS options.
Related MCP server: MCP Paradex Server
Overview
This project provides a bridge between AI assistants (like Claude) and Paradex, a privacy-preserving multi-asset exchange on Starknet with spot, perpetuals, options, and commodity futures. Using the MCP standard, AI assistants can:
Retrieve market data from Paradex
Manage trading accounts and vaults
Place and manage orders
Monitor positions and balance
Prerequisites
Python 3.10+
uv — required for the
uvxrun methodmacOS: Install via
brew install uvso the binary lands in/usr/local/bin, which GUI apps like Claude Desktop can find. The curl-pipe install puts uv in~/.local/bin, which GUI apps cannot see.
Installation
Quick Start
Cursor IDE
Click to automatically configure this MCP server in Cursor:
Claude Code CLI
claude mcp add paradex uvx mcp-paradexSmithery (Claude Desktop)
npx -y @smithery/cli@latest mcp add @tradeparadex/mcp-paradex-py --client claudeStandard Installation
PyPI
pip install mcp-paradexuvx (Recommended)
uvx mcp-paradexDevelopment Setup
Clone the repository:
git clone https://github.com/tradeparadex/mcp-paradex-py.git cd mcp-paradex-pyInstall development dependencies:
uv sync --dev --all-extrasRun locally:
uv run mcp-paradex
Configuration
Environment Variables
Set these environment variables for authentication:
PARADEX_ENVIRONMENT: Set toprod,testnet, ornightly(default:prod)PARADEX_ACCOUNT_PRIVATE_KEY: Your Paradex account private key
Signer mode (no private key)
To trade through a signing proxy that holds the key, set these four and leave
PARADEX_ACCOUNT_PRIVATE_KEY unset:
PARADEX_SIGNER_HEADER: the header the server puts each message hash in, base64PARADEX_SIGNER_SIGNATURE: the placeholder the server sends as the signature, for the proxy to replacePARADEX_ACCOUNT_ADDRESS: your Paradex account addressPARADEX_ACCOUNT_PUBLIC_KEY: the public key of the key the proxy signs with
Every tool call returns a configuration error while any of the four is missing. If a private key is also set, the server uses the signer and logs a warning. Block-trade tools are not available in signer mode.
Outbound proxy
The server sends Paradex API requests through HTTPS_PROXY, HTTP_PROXY or ALL_PROXY
when set, skips the hosts listed in NO_PROXY, and trusts the CA bundle in SSL_CERT_FILE.
Using .env File
cp .env.template .env
# Edit .env with your credentialsClient Configuration
Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"paradex": {
"command": "uvx",
"args": ["mcp-paradex"],
"env": {
"PARADEX_ENVIRONMENT": "testnet",
"PARADEX_ACCOUNT_PRIVATE_KEY": "your_private_key"
}
}
}
}Docker (local / stdio)
# Build image
docker build . -t tradeparadex/mcp-paradex-py
# Run (public only)
docker run --rm -i tradeparadex/mcp-paradex-py
# Run with trading capabilities
docker run --rm -e PARADEX_ACCOUNT_PRIVATE_KEY=your_key -i tradeparadex/mcp-paradex-pyDocker (AWS Lambda / HTTP)
Use Dockerfile.aws for remote deployments via AWS Lambda with the
Lambda Web Adapter.
The adapter bridges Lambda invocations to the server's HTTP endpoint,
so no Lambda-specific code is needed.
# Build
docker build -f Dockerfile.aws -t tradeparadex/mcp-paradex-py-aws .
# Test locally (mirrors Lambda config)
docker run --rm -p 8080:8080 \
-e MCP_TRANSPORT=streamable-http \
-e MCP_STATELESS=true \
-e MCP_PORT=8080 \
-e PARADEX_ENVIRONMENT=prod \
tradeparadex/mcp-paradex-py-awsThe server will be available at http://localhost:8080/mcp.
Deploying to Lambda:
Push the image to ECR
Create a Lambda function from the container image
Set the Lambda Function URL invoke mode to
RESPONSE_STREAMSet environment variables on the Lambda function:
MCP_TRANSPORT=streamable-httpMCP_STATELESS=truePARADEX_ENVIRONMENT=prod(ortestnet)PARADEX_ACCOUNT_PRIVATE_KEY=your_key(optional, for trading)
Available Resources and Tools
Resources
System Resources
paradex://system/config- Get Paradex system configurationparadex://system/time- Get current system timeparadex://system/state- Get system operational state
Market Resources
paradex://markets- List of available marketsparadex://market/summary/{market_id}- Detailed market information
Vault Resources
paradex://vaults- List all vaultsparadex://vaults/config- Global vault configurationparadex://vaults/balance/{vault_id}- Vault balanceparadex://vaults/summary/{vault_id}- Comprehensive vault summaryparadex://vaults/transfers/{vault_id}- Deposit/withdrawal historyparadex://vaults/positions/{vault_id}- Current trading positionsparadex://vaults/account-summary/{vault_id}- Trading account information
Tools
System Tools
paradex_system_config- Get global system configurationparadex_system_state- Get current system state
Market Tools
paradex_markets- Get detailed market informationparadex_market_summaries- Get market summaries with metricsparadex_funding_data- Get historical funding rate dataparadex_orderbook- Get current orderbook with customizable depthparadex_klines- Get historical candlestick dataparadex_trades- Get recent tradesparadex_bbo- Get best bid and offer
Account Tools
paradex_account_summary- Get account summaryparadex_account_positions- Get current positionsparadex_account_fills- Get trade fillsparadex_account_funding_payments- Get funding paymentsparadex_account_transactions- Get transaction history
Order Tools
paradex_open_orders- Get all open ordersparadex_create_order- Create new orderparadex_cancel_orders- Cancel existing ordersparadex_order_status- Get order statusparadex_orders_history- Get historical orders
Vault Tools
paradex_vaults- Get detailed vault informationparadex_vaults_config- Get global vault configurationparadex_vault_balance- Get vault balanceparadex_vault_summary- Get comprehensive vault summaryparadex_vault_transfers- Get deposit/withdrawal historyparadex_vault_positions- Get current vault positionsparadex_vault_account_summary- Get vault trading account info
Trading Analysis Prompts
Market Analysis
market_overview- Comprehensive crypto market overviewmarket_analysis- Detailed technical and microstructure analysis
Position and Portfolio Management
position_management- Comprehensive position analysiscreate_optimal_order- Design optimal order parametershedging_strategy- Develop effective hedging strategiesportfolio_risk_assessment- Thorough portfolio risk analysisliquidation_protection- Identify and mitigate liquidation risks
Investment Strategies
vault_analysis- Comprehensive vault analysis for investment decisionsfunding_rate_opportunity- Identify funding rate arbitrage opportunitiestrading_consultation- Interactive trading advice and consultation
Documentation MCP
Enhanced results with Paradex documentation access:
"paradex-docs-mcp": {
"command": "uvx",
"args": [
"--from",
"mcpdoc",
"mcpdoc",
"--urls",
"Paradex:https://docs.paradex.trade/llms.txt",
"--transport",
"stdio"
]
}Contributing
Please see CONTRIBUTING.md for information on how to contribute to this project, development setup, and our coding standards.
License
Available Tools
33 toolsparadex_account_balanceAccount BalancesARead-onlyIdempotent
Get token balances for your account (e.g. USDC, DIME).
Use this tool when you need to:
- Check how much of each token you hold
- Verify available USDC balance before depositing or withdrawing
- See all token denominations in your account
Example use cases:
- Checking USDC balance before a deposit/withdrawal
- Viewing DIME or other token holdings
Inputs: no named parameters. Returns: result
paradex_account_fillsTrade FillsARead-onlyIdempotent
Analyze your executed trades to evaluate performance and execution quality.
Use this tool when you need to:
- Review your trading history across specific markets
- Calculate your average entry price for multi-fill positions
- Analyze execution quality compared to intended prices
- Track realized PnL from completed trades
- Verify order execution details for reconciliation
Detailed fill information is essential for performance analysis and
understanding how your orders were actually executed.
Example use cases:
- Calculating volume-weighted average price (VWAP) of your entries
- Analyzing execution slippage from your intended prices
- Reviewing trade history for tax or accounting purposes
- Tracking commission costs across different markets
- Identifying which of your strategies produced the best execution
Inputs: market_id (required), start_unix_ms (required), end_unix_ms (required). Returns: result
paradex_account_funding_paymentsFunding PaymentsARead-onlyIdempotent
Track your funding payment history to understand its impact on P&L.
Use this tool when you need to:
- Calculate total funding costs or gains for a position
- Analyze how funding has affected your overall performance
- Plan position timing around funding payment schedules
- Compare funding costs across different markets
- Account for funding in your trading strategy profitability
Funding payments can significantly impact trading P&L,
especially for longer-term positions or in markets with volatile funding rates.
Example use cases:
- Calculating the total funding component of your P&L
- Comparing funding costs against trading profits
- Planning position entries/exits around funding payment times
- Identifying markets where funding has been consistently favorable
- Reconciling funding payments for accounting purposes
Inputs: start_unix_ms (required), end_unix_ms (required), market_id.
paradex_account_keysAccount Keys & TokensARead-onlyIdempotent
List all credentials registered for this account: Paradex subkeys and API tokens.
Use this tool when you need to:
- Audit which subkeys and API tokens have access to the account
- Verify that a generated subkey was successfully registered on Paradex
- Check token expiry dates or identify revoked tokens
- Confirm key setup before starting agent trading
Returns:
- subkeys: Paradex keypairs registered for on-chain signing (e.g. agent keys)
- tokens: JWT / API key tokens for REST API access
Example use cases:
- After registering a subkey, list keys to confirm it appears as active
- Reviewing active tokens to identify any that are near expiry
- Verifying agent credential setup during onboarding
Inputs: include_revoked, with_invalid_tokens. Returns: All credentials registered for this account.
paradex_account_overviewAccount OverviewARead-onlyIdempotent
Get a complete snapshot of your account: margin health, token balances,
open positions, fee rates, and margin methodology in a single call.
Use this instead of calling paradex_account_summary, paradex_account_balance,
and paradex_account_positions separately.
Returns:
- summary: account value, free collateral, margin requirements, health status
- balances: token balances (USDC, DIME, etc.)
- positions: all open positions with P&L and liquidation prices
- info: account fees (maker/taker rates for all product types), account kind,
and isolation mode if applicable
- margin: margin methodology (cross_margin or portfolio_margin) and per-market
leverage/margin-type configuration
Inputs: no named parameters. Returns: Complete account snapshot with margin health, token balances, and open position…
paradex_account_positionsAccount PositionsARead-onlyIdempotent
Analyze your open positions to monitor exposure, profitability, and risk.
Use this tool when you need to:
- Check the status and P&L of all your open positions
- Monitor your liquidation prices and margin requirements
- Assess your exposure across different markets
- Make decisions about position management (scaling, hedging, closing)
Understanding your current positions is fundamental to proper risk management
and is the starting point for many trading decisions.
Example use cases:
- Checking the unrealized P&L of your positions
- Monitoring liquidation prices during market volatility
- Assessing total exposure across related assets
- Verifying entry prices and position sizes
Inputs: no named parameters. Returns: result
paradex_account_profileAccount Profile & SettingsARead-onlyIdempotent
Get static account profile and display settings.
Use this tool when you need to:
- Check your username or referral code
- Review per-market max slippage limits
- Inspect referral configuration (commission rate, discount rate, minimum volume)
- Check TAP affiliate status and share rates
- Review notification preferences or linked social accounts
- See the AI agent WebSocket URL for this account
This data changes infrequently. For live financial data (balances, positions,
margin health, fee rates), use paradex_account_overview instead.
Returns:
- profile: username, referral config, market_max_slippage, notifications,
social links, TAP/XP rates, NFT holdings, AI agent URL
- settings: trading_value_display preference (SPOT_NOTIONAL or MARKET_VALUE)
Inputs: no named parameters. Returns: object
paradex_account_summaryAccount SummaryARead-onlyIdempotent
Get a snapshot of your account's current financial status and trading capacity.
Use this tool when you need to:
- Check your current available and total balance
- Understand your margin utilization and remaining trading capacity
- Verify your account health and distance from liquidation
- Get an overview of realized and unrealized P&L
This provides the essential financial information needed to make informed
trading decisions and manage risk appropriately.
Example use cases:
- Checking available balance before placing new orders
- Monitoring account health during volatile market conditions
- Assessing realized and unrealized P&L for performance tracking
- Verifying margin requirements and utilization
Inputs: no named parameters. Returns: account, account_value, free_collateral, initial_margin_requirement, +7 more
paradex_account_transactionsAccount TransactionsARead-onlyIdempotent
Get account transaction history.
Retrieves a filtered history of account transactions, including deposits,
withdrawals, trades, funding payments, and other account activities.
Use transaction_type and time filters to limit the results and avoid
overwhelming the client.
This tool is valuable for:
- Reconciliation of account activity
- Auditing trading history
- Tracking deposits and withdrawals
- Analyzing funding payments over timeInputs: start_unix_ms (required), end_unix_ms (required), transaction_type, limit. Returns: result
paradex_bboBest Bid/OfferARead-onlyIdempotent
Get the current best available prices for immediate execution decisions.
Use this tool when you need to:
- Make quick trading decisions without full orderbook depth
- Calculate current spread costs before placing orders
- Monitor real-time price changes efficiently
- Get a snapshot of current market conditions
- Determine fair mid-price for calculations
The BBO provides the most essential price information with minimal data,
perfect for quick decisions or when full orderbook depth isn't needed.
Example use cases:
- Calculating current trading spreads before placing orders
- Monitoring real-time price movements efficiently
- Determining execution prices for immediate market orders
- Calculating mid-price for order placement strategies
- Setting appropriate limit order prices to improve fill chances
Inputs: market_id (required). Returns: ask, ask_size, bid, bid_size, +3 more
paradex_cancel_ordersCancel OrdersADestructive
Cancel pending orders to manage exposure or adjust your trading strategy.
Use this tool when you need to:
- Remove stale limit orders that are no longer desirable
- Quickly reduce market exposure during volatility
- Update your order strategy by removing existing orders
- Clear your order book before implementing a new strategy
- React to changing market conditions by canceling pending orders
Order cancellation is a critical risk management function and allows you
to quickly adapt to changing market conditions.
Example use cases:
- Canceling limit orders when your outlook changes
- Removing all orders during unexpected market volatility
- Canceling a specific order identified by order ID
- Clearing all orders for a specific market
- Removing stale orders before placing new ones
Calling without any parameters will cancel all orders.
Succesful response indicates that orders were queued for cancellation.
Check order status using order id.
Inputs: order_id, client_id, market_id. Returns: object
paradex_create_orderCreate OrderADestructive
Execute trades on Paradex with precise control over all order parameters.
Use this tool when you need to:
- Enter a new position based on your trading strategy
- Set limit orders at specific price levels
- Create stop-loss or take-profit orders for risk management
- Implement complex trading strategies with conditional orders
This is the primary tool for executing your trading decisions on Paradex,
with full control over order type, size, price, and execution parameters.
Example use cases:
- Setting limit orders at key support/resistance levels
- Placing stop-limit orders to manage risk on existing positions
- Executing market orders for immediate entry or exit
- Creating reduce-only orders to ensure you don't flip position direction
Succesful response indicates that orders were queued for execution.
Check order status using order id.
Inputs: market_id (required), order_side (required), order_type (required), size (required), +5 more. Returns: account, avg_fill_price, cancel_reason, client_id, +19 more
paradex_filters_modelFilters SchemaARead-onlyIdempotent
Get detailed schema information to build precise data filters.
Use this tool when you need to:
- Understand exactly what fields are available for filtering
- Learn the data types and formats for specific fields
- Build complex JMESPath queries with correct syntax
- Create sophisticated filtering and sorting expressions
Knowing the exact schema helps you construct precise filters that
return exactly the data you need, avoiding trial and error.
Example use cases:
- Learning what fields exist in market data responses
- Finding the correct property names for filtering
- Understanding data types for numerical comparisons
- Building complex multi-criteria filters for large datasets
Inputs: tool_name (required). Returns: object
paradex_funding_dataFunding DataARead-onlyIdempotent
Analyze funding rates for potential funding arbitrage or to understand holding costs.
Use this tool when you need to:
- Calculate expected funding payments for a position
- Find markets with extreme funding rates for potential arbitrage
- Understand historical funding patterns for a market
- Evaluate the cost of holding a position over time
This data is critical for assessing the carrying cost of positions
and identifying potential funding arbitrage opportunities.
Example use cases:
- Finding markets with negative funding for "paid to hold" opportunities
- Calculating the funding component of a trade's P&L
- Comparing funding rates across different assets for relative value trades
- Analyzing funding rate volatility to predict potential rate changes
Inputs: market_id (required), start_unix_ms (required), end_unix_ms (required). Returns: result
paradex_generate_subkeyGenerate SubkeyA
Generate a Paradex keypair for use as a subkey.
The private key is persisted locally and never leaves the machine.
Only the public key is returned so the frontend can register it on
Paradex on behalf of the agent.
Use this tool when you need to:
- Provision a new subkey for agent trading
- Create a keypair before registering the public key on Paradex
Example use cases:
- Setting up a new agent with its own trading subkey
- Rotating to a fresh subkey for an existing account
Inputs: name, path. Returns: Result of a locally generated Paradex subkey.
paradex_klinesCandlestick DataARead-onlyIdempotent
Analyze historical price patterns for technical analysis and trading decisions.
Use this tool when you need to:
- Perform technical analysis on historical price data
- Identify support and resistance levels from price history
- Calculate indicators like moving averages, RSI, or MACD
- Backtest trading strategies on historical data
- Visualize price action over specific timeframes
Candlestick data is fundamental for most technical analysis and trading decisions,
providing structured price and volume information over time.
Example use cases:
- Identifying chart patterns for potential entries or exits
- Calculating technical indicators for trading signals
- Determining volatility by analyzing price ranges
- Finding significant price levels from historical support/resistance
- Measuring volume patterns to confirm price movements
Inputs: market_id (required), start_unix_ms (required), end_unix_ms (required), resolution. Returns: result
paradex_marketsMarketsARead-onlyIdempotent
Find markets that match your trading criteria or get detailed market specifications.
Use this tool when you need to:
- Understand exact tick sizes and minimum order sizes before placing trades
- Find all markets for a specific asset (e.g., all BTC-based markets)
- Compare contract specifications across different markets
- Identify markets with specific characteristics for your trading strategy
Retrieves comprehensive details about specified markets, including
base and quote assets, tick size, minimum order size, and other
trading parameters. If "ALL" is specified or no market IDs are provided,
returns details for all available markets.
Example use cases:
- Finding the minimum order size for a new trade
- Identifying markets with the smallest tick size for precise entries
- Checking which assets are available for trading
`asset_kind` is the type of asset in the market: `PERP` (perpetual futures),
`PERP_OPTION` (perpetual options), `SPOT` (spot markets), `OPTION` (dated/expiring options),
or `FUTURE` (dated futures).
You can use JMESPath expressions (https://jmespath.org/specification.html) to filter, sort, or limit the results.
Use the `paradex_filters_model` tool to get the filters for a tool.
Examples:
- Filter by base asset: "[?base_asset=='BTC']"
- Sort by 24h volume: "sort_by([*], &volume_24h)"
- Limit to top 5 by volume: "[sort_by([*], &to_number(volume_24h))[-5:]]"
Inputs: market_ids, jmespath_filter, limit, offset. Returns: Paginated list of market details.
paradex_market_summariesMarket SummariesARead-onlyIdempotent
Identify the most active or volatile markets and get current market conditions.
Use this tool when you need to:
- Find the most active markets by volume for liquidity analysis
- Discover markets with significant price movements for momentum strategies
- Compare current prices across multiple assets
- Identify markets with unusual behavior for potential opportunities
- Get the best bid/ask (BBO) for a market — the summary includes bid and ask fields
- Get the current funding rate — the summary includes funding_rate
Retrieves current market summary information including mark price, best bid/ask,
last traded price, 24h volume and price change, funding rate, open interest, and
underlying spot price. If "ALL" is specified or no market IDs are provided,
returns summaries for all available markets.
Prefer this tool over separate paradex_bbo or paradex_funding_data calls when you
need price context before making a trading recommendation — all that data is here.
Example use cases:
- Finding high-volatility markets for short-term trading
- Identifying top gainers and losers for the day
- Comparing volume across different markets to find liquidity
- Getting the current price and 24-hour range for price analysis
- Checking bid/ask spread and funding rate before placing an order
You can use JMESPath expressions (https://jmespath.org/specification.html) to filter, sort, or limit the results.
Use the `paradex_filters_model` tool to get the filters for a tool.
Examples:
- Filter by high price: "[?high_price > `10000`]"
- Sort by volume: "sort_by([*], &volume)"
- Get top 3 by price change: "[sort_by([*], &to_number(price_change_percent))[-3:]]"
Inputs: market_ids, jmespath_filter, limit, offset. Returns: Paginated list of market summaries.
paradex_open_ordersOpen OrdersARead-onlyIdempotent
Monitor your active orders to track execution status and manage your trading strategy.
Use this tool when you need to:
- Check which of your orders are still pending execution
- Verify limit order prices and remaining quantities
- Determine which orders might need cancellation or modification
- Get a complete picture of your current market exposure
Keeping track of your open orders is essential for effective order management
and avoiding duplicate or conflicting trades.
Example use cases:
- Checking if your limit orders have been partially filled
- Verifying that a recently placed order was accepted by the exchange
- Identifying stale orders that should be canceled or modified
- Getting a consolidated view of all pending orders across markets
Inputs: market_id, limit, offset. Returns: Paginated list of order states.
paradex_orderbookOrder BookARead-onlyIdempotent
Analyze market depth and liquidity to optimize order entry and execution.
Use this tool when you need to:
- Assess true liquidity before placing large orders
- Identify potential support/resistance levels from order clusters
- Determine optimal limit order prices for higher fill probability
- Detect order imbalances that might signal price direction
Understanding the orderbook is essential for effective trade execution,
especially for larger orders or in less liquid markets.
Example use cases:
- Finding the optimal limit price to ensure your order gets filled
- Estimating potential slippage for market orders of different sizes
- Identifying large resting orders that might act as support/resistance
- Detecting order book imbalances that could predict short-term price moves
Inputs: market_id (required), depth. Returns: object
paradex_orders_historyOrders HistoryARead-onlyIdempotent
Get historical orders.
Retrieves the history of orders for the account, including filled, canceled, and expired orders. This is useful for analyzing past trading activity and performance.
Inputs: market_id (required), start_unix_ms (required), end_unix_ms (required). Returns: result
paradex_order_statusOrder StatusARead-onlyIdempotent
Check the detailed status of a specific order for execution monitoring.
Use this tool when you need to:
- Confirm if a particular order was accepted and is active
- Check if an order has been filled, partially filled, or canceled
- Get execution details for a specific order
- Diagnose issues with order placement
- Track the status of important orders individually
Order status tracking is essential for verifying execution status
and troubleshooting any issues with specific orders.
Example use cases:
- Checking if a recently placed limit order is active in the book
- Verifying fill details of a specific order
- Determining why an order might have been rejected
- Confirming cancellation status of an order you attempted to cancel
- Getting execution timestamps for order lifecycle analysis
Inputs: order_id (required), client_id (required). Returns: account, avg_fill_price, cancel_reason, client_id, +19 more
paradex_pre_trade_checkPre-Trade CheckARead-onlyIdempotent
Validate a trade idea before submitting an order.
Use this tool when you need to:
- Confirm your account has sufficient free collateral for a trade
- Check whether a given order size is within market limits
- Get current bid/ask and existing position in one call
- Receive a single ready_to_trade flag with human-readable reasons if not ready
Use this instead of calling paradex_account_summary, paradex_account_positions,
paradex_market_summaries, and paradex_markets separately before placing an order.
Returns:
- account_status: account health (ACTIVE, LIQUIDATION, etc.)
- free_collateral: available collateral for new positions
- current_position: existing open position in this market, if any
- bbo: best bid/ask, mark price, and current funding rate
- market_constraints: tick size, min notional, position limit, order size increment
- estimates: fee, slippage, funding cost, and break-even using the account's actual fee tier
- ready_to_trade: True when account is healthy, collateral is positive,
and size is within market limits
- not_ready_reasons: list of reasons why ready_to_trade is False (empty when True)
Inputs: market_id (required), side (required), size (required). Returns: Result of a pre-trade readiness check for a specific market and order size.
paradex_system_configSystem ConfigurationARead-onlyIdempotent
Understand the exchange's global parameters and portfolio margin risk factors.
Use this tool when you need to:
- Check fee schedules before placing trades
- Verify trading limits and restrictions
- Understand exchange-wide parameters that affect your trading
- Review portfolio margin factors (hedged/unhedged margin, vol-shock params) per asset
Returns:
- config: raw system configuration (contract addresses, chain IDs, fee tiers, etc.)
- portfolio_margin: per-asset portfolio margin parameters used in PM calculations
Example use cases:
- Checking current fee tiers for different markets
- Verifying maximum leverage available for specific markets
- Reviewing portfolio margin risk factors before switching margin methodology
Inputs: no named parameters. Returns: System configuration combined with portfolio margin parameters.
paradex_system_stateSystem StateARead-onlyIdempotent
Verify the exchange is fully operational before executing trades.
Use this tool when you need to:
- Check if Paradex is functioning normally before placing important orders
- Verify system status if you encounter unexpected behavior
- Confirm that maintenance periods are not in effect
- Check exchange clock synchronization with your own systems
This is especially important before executing critical trades or when
experiencing unexpected behavior from other API calls.
Example use cases:
- Verifying the exchange is operational before executing a trading strategy
- Checking if maintenance mode is active when experiencing delays
- Confirming exchange status during periods of market volatility
- Diagnosing API issues by checking system health
Inputs: no named parameters. Returns: Model representing the current state of the Paradex system.
paradex_tradesMarket TradesARead-onlyIdempotent
Analyze actual market transactions to understand market sentiment and liquidity.
Use this tool when you need to:
- Detect large trades that might signal institutional activity
- Calculate average trade size during specific periods
- Identify buy/sell pressure imbalances
- Monitor execution prices vs. order book prices
- Understand market momentum through trade flow
Trade data provides insights into actual market activity versus just orders,
helping you understand how other participants are behaving.
Example use cases:
- Detecting large "whale" transactions that might influence price
- Analyzing trade sizes to gauge market participation
- Identifying periods of aggressive buying or selling
- Understanding trade frequency as an indicator of market interest
- Comparing executed prices to orderbook mid-price for market impact analysis
Inputs: market_id (required), start_unix_ms (required), end_unix_ms (required). Returns: result
paradex_vault_account_summaryVault Account SummaryARead-onlyIdempotent
Get a comprehensive overview of a vault's trading account status.
Use this tool when you need to:
- Check account health and available margin
- Monitor total exposure and leverage
- Understand risk metrics and account status
- Assess trading capacity before placing new orders
- Get a consolidated view of account performance
This provides essential information about account standing and
trading capacity to inform risk management decisions.
Example use cases:
- Checking available margin before placing new orders
- Monitoring account health during market volatility
- Assessing total exposure across all markets
- Understanding maintenance margin requirements
- Planning position adjustments based on account metrics
Inputs: vault_address (required). Returns: result
paradex_vault_balanceVault BalanceARead-onlyIdempotent
Get the current balance of a specific vault.
Retrieves the current balance information for a specific vault, including available funds, locked funds, and total balance. This is essential for understanding the financial state of a vault before executing trades or withdrawals.
Inputs: vault_address (required). Returns: result
paradex_vault_overviewVault OverviewARead-onlyIdempotent
Get a complete operational snapshot of a vault: token balances, open positions,
and trading account health in a single call.
Use this instead of calling paradex_vault_balance, paradex_vault_positions,
and paradex_vault_account_summary separately.
Returns:
- balances: vault token balances
- positions: all open positions with P&L and liquidation prices
- account_summary: margin health, free collateral, leverage
Inputs: vault_address (required). Returns: Complete vault operational snapshot with token balances, open positions, and ac…
paradex_vault_positionsVault PositionsARead-onlyIdempotent
Monitor active trading positions to track performance and manage risk.
Use this tool when you need to:
- Get a complete view of all open positions for a vault
- Monitor unrealized P&L across all positions
- Check liquidation prices and margin requirements
- Assess position sizing and leverage across markets
- Track entry prices and position duration
Position monitoring is fundamental to risk management and provides
the necessary information for trade management decisions.
Example use cases:
- Checking the current status of all open trades
- Monitoring unrealized profit/loss across positions
- Assessing liquidation risk during market volatility
- Comparing performance across different markets
- Planning adjustments to position sizes or leverage
Inputs: vault_address (required). Returns: result
paradex_vaultsVaultsARead-onlyIdempotent
Get detailed information about a specific vault or all vaults if no address is provided.
Retrieves comprehensive details about a specific vault identified by its address,
including configuration, permissions, and other vault-specific parameters.
Use jmespath_filter to reduce the number of results as much as possible as number of vaults can be large.
You can use JMESPath expressions to filter, sort, or limit the results.
Examples:
- Filter by owner: "[?owner_account=='0x123...']"
- Filter by status: "[?status=='ACTIVE']"
- Find vaults with specific strategy: "[?contains(strategies, 'strategy_id')]"
- Sort by creation date: "sort_by([*], &created_at)"
- Limit to newest vaults: "sort_by([*], &created_at)[-5:]"
- Select specific fields: "[*].{address: address, name: name, kind: kind, status: status}"
Inputs: vault_address, jmespath_filter, limit, offset. Returns: Paginated list of vaults.
paradex_vault_summaryVault SummaryARead-onlyIdempotent
Get a comprehensive summary of a specific vault or all vaults if no address is provided.
Retrieves a summary of all important information about a vault,
including balance, positions, recent activity, and performance metrics.
This provides a high-level overview of the vault's current state.
Use jmespath_filter to reduce the number of results as much as possible as number of vaults can be large.
You can use JMESPath expressions to filter, sort, or transform the results.
Examples:
- Filter by TVL: "[?to_number(tvl) > `10000`]"
- Filter by performance: "[?to_number(total_roi) > `5.0`]"
- Sort by TVL (descending): "reverse(sort_by([*], &to_number(tvl)))"
- Get top performers: "sort_by([*], &to_number(total_roi))[-3:]"
- Filter by recent returns: "[?to_number(roi_24h) > `0.5`]"
- Extract specific metrics: "[*].{address: address, tvl: tvl, total_roi: total_roi, volume_24h: volume_24h}"
Inputs: vault_address, jmespath_filter, limit, offset. Returns: Paginated list of vault summaries.
paradex_vault_transfersVault TransfersARead-onlyIdempotent
Track deposit and withdrawal history for auditing and reconciliation.
Use this tool when you need to:
- Verify deposits have completed and are available for trading
- Track withdrawal status and confirm transaction settlement
- Audit the complete fund flow history for a vault
- Reconcile on-chain transactions with platform records
- Understand historical capital allocation patterns
Complete transfer history is essential for proper accounting and provides
a clear audit trail of all capital movements.
Example use cases:
- Confirming that a recent deposit was credited to your account
- Tracking the status of pending withdrawals
- Creating transaction reports for accounting or tax purposes
- Verifying the total amount deposited over time
- Analyzing deposit/withdrawal patterns for strategy insights
Inputs: vault_address (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 33 tools
All 33 tools have clearly distinct purposes. Account, market, order, system, and vault tools each target specific resources and actions without overlap. For example, account_balance vs account_fills vs account_positions are well-separated, and market tools like bbo, orderbook, klines, and market_summaries each provide different granularity of data.
Tools follow a consistent pattern: 'paradex_' prefix followed by snake_case area and action (e.g., paradex_account_balance, paradex_cancel_orders). Abbreviations like 'bbo' and 'klines' are standard in trading and do not break the pattern. The naming is predictable and clear.
With 33 tools, the count is above the typical well-scoped range of 3–15 and falls into the borderline/heavy category (16–25 is borderline; above 25 is considered too many per calibration). However, each tool serves a distinct purpose for a comprehensive trading platform, so while high, it is not excessive for the domain.
The tool surface covers core trading operations (account, orders, market data), vault management, and system status. Minor gaps exist: no dedicated deposit/withdrawal tool, no order amendment, and no API token management beyond listing. These are non-critical but prevent a perfect score.
Maintenance
Related MCP Connectors
Trade Papertrade BTC and ETH perps from Claude, ChatGPT, Codex, Cursor and any MCP client.
OpenFinance gives any AI agent easy trading across every major market through one hosted MCP server. Trade crypto spot and perpetuals on Hyperliquid with market, limit and TWAP orders, leverage and margin control. Trade stocks, indices, commodities, forex and pre-IPO names as Hyperliquid HIP-3 perps. Trade Polymarket prediction markets with odds, order books, positions, PnL and trader leaderboards. Swap and bridge across 40+ EVM chains and Solana with Relay and Jupiter, find memecoins across 200+ chains, launch tokens on Robinhood Chain and Solana, and buy crypto with card, bank or UPI. Write actions are designed to ask for your confirmation first. Connect with OAuth (sign in to OpenFinance and approve) or an API key. Works with Claude, ChatGPT, Cursor, VS Code, Codex and any MCP client. No install. Home: https://openfinance.tech/agents · Docs: https://docs.openfinance.tech · GitHub: https://github.com/openfinance-tech/mcp
Trade Hyperliquid perps, stocks, gold, oil and pre-IPO from AI agents. Hosted; keys can't withdraw.
Cross-asset market data, LLM gateway and ML forecasts for AI agents. USDC via x402 + MPP.
Related MCP Servers
- AlicenseAqualityFmaintenanceA Model Context Protocol server implementation that enables AI assistants to interact with the Paradex perpetual futures trading platform, allowing for retrieving market data, managing trading accounts, placing orders, and monitoring positions.169MIT
- AlicenseAqualityNot gradedmaintenanceA bridge between AI assistants and the Paradex perpetual futures trading platform that enables retrieving market data, managing trading accounts, placing orders, and monitoring positions.26MIT
- AlicenseBqualityCmaintenanceProvides Binance futures market data, trading capabilities, and technical indicators to AI assistants through the Model Context Protocol.5766 npm1MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to securely trade on Hyperliquid perpetual exchange, including order placement, position management, market data retrieval, and vault operations via natural language.29 PyPI24MIT