# Prop Firm Intelligence MCP Server (`andrew_avina/prop-firm-intel-mcp`) Actor

The prop trading firm industry has exploded to over $3 billion in annual challenge fee revenue. Retail traders spend $100â€“$1,500 per challenge attempt, often without any rigorous analysis of whether the challenge parameters are actually beatable given their strategy's histor...

- **URL**: https://apify.com/andrew\_avina/prop-firm-intel-mcp.md
- **Developed by:** [Andrew Avina](https://apify.com/andrew_avina) (community)
- **Categories:** MCP servers, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## prop-firm-intel-mcp

> **Which prop firm challenge actually has positive EV for your strategy? Now you can calculate it.**

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-brightgreen)](https://apify.com/actors/prop-firm-intel-mcp)
[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-blue)](https://modelcontextprotocol.io)
[![Firms Covered](https://img.shields.io/badge/Firms%20Covered-7-orange)](https://apify.com)
[![EV Calculator](https://img.shields.io/badge/EV%20Calculator-Included-success)](https://apify.com)
[![Updated](https://img.shields.io/badge/Data-Static%20DB%20%2F%20Manually%20Verified-lightgrey)](https://apify.com)

---

### What Is This?

The prop trading firm industry has exploded to over **$3 billion in annual challenge fee revenue**. Retail traders spend $100â€“$1,500 per challenge attempt, often without any rigorous analysis of whether the challenge parameters are actually beatable given their strategy's historical performance.

**prop-firm-intel-mcp** gives AI assistants a structured, queryable database of 7 major prop trading firms â€” with complete challenge rules, pricing, payout structures, and critically, an **expected value (EV) calculator** that takes your win rate and risk:reward ratio as inputs and tells you mathematically which challenges you can beat.

Stop guessing. Start calculating.

This actor uses a **static, manually-verified database** â€” not live web scraping. Prop firm rules change frequently; we update the database with each verified rule change and version-stamp every dataset so you always know exactly what data you're working with.

---

### Firms Covered

| Firm | Challenge Tiers | Profit Target | Max Drawdown | Payout Split | Starting Price |
|---|---|---|---|---|---|
| **TopstepX** | Futures, Express | 6% | 3% daily / 6% total | 90% | $49/month |
| **Apex Trader Funding** | Full, Static | 6% | 3% daily / 6% trailing | 100% (after fee) | $147 one-time |
| **FTMO** | FTMO Challenge, Swing | 10% | 5% daily / 10% total | 80â€“90% | $155 one-time |
| **MyFundedFutures** | Standard, Starter | 6% | 2% daily / 6% trailing | 90% | $49/month |
| **E8 Markets** | Standard, Straight-Through | 8% | 5% daily / 8% total | 80% | $228 one-time |
| **The Trading Pit** | Standard | 8% | 5% daily / 8% total | 80% | â‚¬99 one-time |
| **Funded Trading Plus** | Standard, Accelerated | 10% | 5% daily / 10% total | 90% | $119 one-time |

---

### Who Uses This?

| User Type | Use Case | Value |
|---|---|---|
| **Retail Traders** | Choosing which challenge to attempt given their trading strategy | Mathematical EV calculation instead of guessing |
| **Trading Coaches** | Recommending prop firms to students | Objective data to support recommendations |
| **Financial Newsletter Writers** | Prop firm comparison content | Structured data for comparison tables and analysis |
| **Quantitative Retail Traders** | Backtesting-informed challenge selection | Input real backtest stats; get real EV outputs |
| **Trading Discord/Community Moderators** | Answering member questions about prop firms | Fast structured lookup without visiting 7 different websites |
| **Social Media Trading Educators** | Content creation around prop firms | Comparison data for YouTube/TikTok content |
| **Algorithmic Retail Traders** | EA/bot prop firm compatibility checking | Rule-set filtering for news trading, overnight holds, EA use |

---

### Feature Overview

| Feature | Detail |
|---|---|
| **Compare Mode** | Side-by-side comparison of all 7 firms on any parameter |
| **Firm Rules Mode** | Deep dive into one firm's complete rule set |
| **Promotions Mode** | Active discount codes and promotional pricing |
| **EV Calculator** | Input win rate + R:R ratio â†’ expected value per challenge |
| **Rule Compatibility Filter** | Filter firms by: EA-allowed, news-trading-allowed, overnight-holds-allowed, weekend-holds-allowed |
| **Payout Analysis** | Calculate expected monthly payout given account size + win rate |
| **Cost Recovery Analysis** | How many winning months before your challenge fee is recovered |
| **Risk-Adjusted ROI** | EV normalized to challenge cost for cross-firm comparison |
| **Historical Price Data** | Track when firms have run promotions and how aggressive |
| **Version-Stamped Data** | Every dataset includes a verification date and change log |

---

### The EV Calculator â€” How It Works

Prop firm challenges are a **probabilistic event** with a defined cost, a defined success probability, and a defined payout distribution. The EV calculator treats them correctly as such.

**Inputs:**
- `winRate`: Your historical win rate (0.0â€“1.0)
- `rrRatio`: Your average risk:reward ratio (e.g., 1.5 means you risk 1 to make 1.5)
- `avgTradesPerDay`: Your average daily trade count
- `challengeDurationDays`: Challenge duration in days
- `challengeCost`: One-time or monthly challenge cost
- `accountSize`: Account size being challenged for

**The model calculates:**
1. **Expected daily P&L** = `winRate Ã— rrRatio Ã— riskPerTrade - (1 - winRate) Ã— riskPerTrade`
2. **Probability of hitting profit target** = Monte Carlo simulation over `challengeDurationDays` given your edge and daily variance
3. **Probability of breaching drawdown** = Same simulation, tracking drawdown path
4. **Net EV per challenge attempt** = `P(pass) Ã— expectedPayoutYear1 - P(fail) Ã— challengeCost`
5. **Break-even win rate** = The minimum win rate at which this challenge has positive EV given your R:R

**Important:** EV is calculated over the first 12 months of funded trading (not the challenge phase alone), because the real profit opportunity is in the payout stream, not the challenge itself.

---

### Quick Start

#### MCP Mode

```json
{
  "mcpServers": {
    "prop-firm-intel": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/mcp-client",
        "--actor-id",
        "your-username/prop-firm-intel-mcp",
        "--token",
        "YOUR_APIFY_TOKEN"
      ]
    }
  }
}
````

Ask Claude:

> "My backtest shows a 52% win rate with 1.8 R:R ratio, trading ES futures, averaging 4 trades per day. Which prop firm challenge has the best EV for my strategy? I need to allow overnight holds."

#### Direct API Mode

```bash
curl -X POST https://api.apify.com/v2/acts/your-username~prop-firm-intel-mcp/run-sync \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "calculate_ev",
    "winRate": 0.52,
    "rrRatio": 1.8,
    "avgTradesPerDay": 4,
    "requireOvernightHolds": true,
    "sortBy": "netEV"
  }'
```

***

### MCP Tools Reference

#### `compare_firms`

Get a structured comparison across all 7 firms on specified parameters.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `compareOn` | array | No | Fields to compare: `profitTarget`, `maxDailyDrawdown`, `maxTotalDrawdown`, `payoutSplit`, `price`, `challengeDuration`, `minimumTradingDays`, `payoutFrequency` |
| `accountSize` | string | No | Filter to specific account size tier (e.g., `50000`, `100000`, `200000`) |
| `instrumentType` | string | No | `futures`, `forex`, `cfd`, `crypto` |
| `requireEAAllowed` | boolean | No | Filter to firms that allow EAs/bots |
| `requireOvernightHolds` | boolean | No | Filter to firms allowing overnight positions |
| `requireWeekendHolds` | boolean | No | Filter to firms allowing weekend holds |
| `requireNewsTrading` | boolean | No | Filter to firms allowing news trading |
| `sortBy` | string | No | Sort results by: `price`, `payoutSplit`, `profitTarget`, `drawdown` |

**Response:**

```json
{
  "comparison": [
    {
      "firm": "Apex Trader Funding",
      "accountSizes": [25000, 50000, 75000, 100000, 150000, 250000, 300000],
      "selectedTier": {
        "size": 50000,
        "price": 147,
        "profitTarget": 3000,
        "profitTargetPct": 0.06,
        "maxDailyDrawdown": 1500,
        "maxTotalDrawdown": 2500,
        "drawdownType": "trailing",
        "minTradingDays": 7,
        "challengeDurationDays": "unlimited",
        "payoutSplit": 1.00,
        "payoutFrequency": "monthly",
        "payoutType": "account_funded",
        "eaAllowed": true,
        "overnightAllowed": true,
        "weekendAllowed": true,
        "newsTrading": true,
        "consistencyRule": false
      },
      "dataVersion": "2024-Q1-v2",
      "lastVerified": "2024-01-10"
    }
  ],
  "totalFirmsReturned": 7,
  "filtersApplied": ["requireOvernightHolds=true"]
}
```

#### `get_firm_rules`

Complete rule set for a single firm, including edge cases and gotchas.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `firm` | string | Yes | Firm name: `TopstepX`, `Apex`, `FTMO`, `MyFundedFutures`, `E8Markets`, `TradingPit`, `FundedTradingPlus` |
| `accountSize` | number | No | Specific account size tier |
| `includeGotchas` | boolean | No | Include documented rule edge cases and traps (default: true) |
| `includeHistory` | boolean | No | Include rule change history (default: false) |

**The `gotchas` array** is the highest-value output of this tool. Examples already documented:

- FTMO: Consistency rule means you can't make more than 30% of profits on any single day (can void your payout)
- Apex: Trailing drawdown is calculated from peak equity, not starting balance â€” this makes the effective drawdown tighter than advertised
- TopstepX: Express account profit splits change after month 6
- MyFundedFutures: EOD position flattening required (all positions must close before market close)

#### `get_promotions`

Current active promotions and discount codes.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `firm` | string | No | Specific firm (default: all firms) |
| `includeExpired` | boolean | No | Include recently expired promotions (default: false) |

**Note:** Promotional data is manually verified and timestamped. Promotions change frequently â€” always verify directly with the firm before purchasing.

#### `calculate_ev`

**This is the core tool.** Calculate expected value for each firm's challenge given your trading statistics.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `winRate` | number | Yes | Historical win rate (0.0â€“1.0) |
| `rrRatio` | number | Yes | Average risk:reward ratio |
| `avgTradesPerDay` | number | Yes | Average number of trades per trading day |
| `riskPerTradePercent` | number | No | Risk per trade as % of account (default: 1.0) |
| `consistencyPct` | number | No | Day-to-day consistency score (0-1, 1=perfectly consistent) |
| `accountSize` | number | No | Preferred account size (default: 100000) |
| `firmFilter` | array | No | Limit to specific firms |
| `requireOvernightHolds` | boolean | No | Filter firms requiring EOD flat |
| `requireEAAllowed` | boolean | No | Filter to EA-compatible firms |
| `simulationRuns` | integer | No | Monte Carlo iterations (default: 10000, max: 100000) |
| `sortBy` | string | No | `netEV`, `evPerDollarRisked`, `passProbability`, `breakEvenWinRate` |

**Response:**

```json
{
  "evAnalysis": [
    {
      "firm": "Apex Trader Funding",
      "accountSize": 100000,
      "challengeCost": 207,
      "passProbability": 0.673,
      "expectedTimeToPass": "23 trading days",
      "payoutYear1": {
        "expectedMonthlyPayout": 1847,
        "expectedAnnualPayout": 22164
      },
      "ev": {
        "netEV": 14628,
        "evPerDollarInvested": 70.67,
        "breakEvenWinRate": 0.44,
        "breakEvenRR": 1.1
      },
      "riskMetrics": {
        "drawdownBreachProbability": 0.189,
        "expectedAttempts": 1.49,
        "totalExpectedCost": 308
      },
      "verdict": "POSITIVE_EV",
      "verdictDetail": "Your 52% win rate and 1.8 R:R creates a substantial edge over the 6% profit target with trailing drawdown. Expected to pass in 1.49 attempts. Main risk: trailing drawdown mechanics require discipline after early winning days."
    }
  ],
  "inputStats": {
    "impliedEdge": 0.136,
    "dailyExpectancy": 0.068,
    "kellyFraction": 0.213
  },
  "bestFirm": "Apex Trader Funding",
  "simulationRuns": 10000,
  "dataVersion": "2024-Q1-v3"
}
```

***

### Use Case Recipes

#### Recipe 1: "Which challenge should I take?"

**Prompt:**

> "My backtest over 2 years: 48% win rate, 2.1 R:R average, 3 trades per day on NQ futures. I risk 0.8% per trade. I need overnight holds to be allowed, no consistency rule. Which prop firm has the highest EV for my strategy? Show me the top 3 with full math."

#### Recipe 2: "Is this challenge beatable at all?"

**Prompt:**

> "I trade FTMO's $100K standard challenge (10% target, 5% daily DD, 10% total DD). My stats are 45% win rate and 1.5 R:R, 5 trades per day. What's my pass probability? What's the minimum win rate I'd need to break even on this challenge? Is it worth attempting?"

#### Recipe 3: Newsletter Comparison Table

**Prompt:**

> "Create a comprehensive comparison table of all 7 prop firms for futures traders wanting a $100K account. Include: price, profit target, max drawdown type (trailing vs static), payout split, whether overnight holds are allowed, and whether EAs are allowed. Format as a markdown table suitable for a newsletter."

#### Recipe 4: Trading Coach Client Recommendation

**Prompt:**

> "My student has a 55% win rate with 1.3 R:R. He averages 2 trades per day, always closes positions by end of day (no overnights), and does not use an EA. His budget is $200 max for the challenge fee. What firm should he try, and what does his EV look like?"

#### Recipe 5: "Check for current deals"

**Prompt:**

> "Show me all current prop firm promotions and discount codes. I'm about to buy an Apex or FTMO challenge â€” is either running a discount right now?"

***

### Important Disclosures

**This actor contains a static database, not live data.** Prop firm rules change frequently â€” sometimes without public announcement. Always verify current rules directly with the firm before paying any challenge fee.

**The EV calculator is a mathematical model, not a guarantee.** Backtested win rates and R:R ratios often do not persist in live trading conditions. The model also does not account for: psychological factors, rule violations, platform issues, firm insolvency risk, or payout disputes.

**Prop firm risk:** Multiple prop trading firms have abruptly ceased operations or changed payout rules in 2022â€“2024. The data includes a `firmRisk` field with a qualitative assessment of each firm's apparent stability, but this is not financial advice.

**Data version:** Every response includes a `dataVersion` timestamp. Always check this â€” if the version is more than 60 days old, verify key rules directly with the firm.

***

### Claude Desktop Configuration

```json
{
  "mcpServers": {
    "prop-firm-intel": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/mcp-client",
        "--actor-id",
        "your-username/prop-firm-intel-mcp",
        "--token",
        "apify_api_XXXXXXXXXXXXXXXXXXXX"
      ]
    }
  }
}
```

**Test prompt:** "Compare TopstepX and Apex Trader Funding for a futures trader at the $100K level. What are the key rule differences?"

***

### Input Schema (Full)

```json
{
  "mode": {
    "type": "string",
    "enum": ["compare", "firm_rules", "promotions", "calculate_ev"],
    "description": "Operating mode",
    "default": "compare"
  },
  "firm": {
    "type": "string",
    "enum": ["TopstepX", "Apex", "FTMO", "MyFundedFutures", "E8Markets", "TradingPit", "FundedTradingPlus"]
  },
  "winRate": {
    "type": "number",
    "minimum": 0.01,
    "maximum": 0.99,
    "description": "Historical win rate as decimal (e.g., 0.52 for 52%)"
  },
  "rrRatio": {
    "type": "number",
    "minimum": 0.1,
    "maximum": 20,
    "description": "Average risk to reward ratio (e.g., 1.8 means risk 1 to make 1.8)"
  },
  "avgTradesPerDay": {
    "type": "number",
    "minimum": 0.1,
    "maximum": 500,
    "description": "Average number of completed trades per trading day"
  },
  "accountSize": {
    "type": "number",
    "enum": [10000, 25000, 50000, 100000, 150000, 200000, 300000],
    "description": "Target account size in USD"
  },
  "requireOvernightHolds": { "type": "boolean", "default": false },
  "requireWeekendHolds": { "type": "boolean", "default": false },
  "requireEAAllowed": { "type": "boolean", "default": false },
  "requireNewsTrading": { "type": "boolean", "default": false },
  "simulationRuns": {
    "type": "integer",
    "minimum": 1000,
    "maximum": 100000,
    "default": 10000
  },
  "sortBy": {
    "type": "string",
    "enum": ["netEV", "evPerDollarRisked", "passProbability", "breakEvenWinRate", "price"],
    "default": "netEV"
  }
}
```

***

### Pricing & Usage

| Tier | Price | Includes |
|---|---|---|
| **Free** | $0 | 50 queries/month (compare + firm\_rules only) |
| **Trader** | $9/month | 500 queries/month + EV calculator |
| **Coach** | $29/month | 5,000 queries/month + batch + promotions monitor |

***

### Data Source & Verification

- **Source:** Manually compiled from official firm websites, terms of service, and verified trader reports
- **Verification cadence:** Monthly audit against firm websites; emergency updates when major rule changes are reported by community
- **Data version format:** `YYYY-QN-vN` (e.g., `2024-Q1-v3` = third update in Q1 2024)
- **Community contribution:** Rule change reports accepted via GitHub Issues; verified changes credited

***

### Technical Notes

- EV calculator uses Monte Carlo simulation (default 10,000 runs); set `simulationRuns: 100000` for higher precision at the cost of ~3s additional processing time
- The Kelly Fraction is calculated and returned for reference; it should not be used directly as the risk-per-trade input for live trading without a significant fraction (suggest 1/4 Kelly at most)
- Drawdown simulation uses geometric Brownian motion with drift; does not model fat-tail events or correlated loss streaks â€” real performance will have higher drawdown tail risk than modeled
- Trailing drawdown mechanics are simulated correctly: drawdown tracks from peak equity, not starting balance

***

### Support & Issues

- **GitHub:** [github.com/your-username/prop-firm-intel-mcp](https://github.com)
- **Rule change reports:** Submit via GitHub Issues with source documentation
- **Email:** support@your-domain.com

*This actor is not affiliated with any prop trading firm. Not financial advice. Prop trading involves substantial risk of loss.*

# Actor input Schema

## `mode` (type: `string`):

Operation: 'compare' (rank all firms), 'firm\_rules' (detailed rules for one firm), 'promotions' (current discounts), 'calculate\_ev' (expected value for your stats)

## `firmName` (type: `string`):

Prop firm name for firm\_rules or calculate\_ev mode. Supported: TopstepX, Apex Trader Funding (or Apex), FTMO, MyFundedFutures (or MFF), E8 Markets, The Trading Pit, Funded Trading Plus

## `accountSize` (type: `integer`):

Desired trading account size in USD (e.g. 25000, 50000, 100000, 150000, 200000). Used in compare and calculate\_ev modes.

## `assetClass` (type: `string`):

Filter firms by supported asset class. Use 'all' to see every firm.

## `priority` (type: `string`):

What to optimize for when comparing firms: highest\_payout (best % split), lowest\_cost (cheapest challenge relative to account size), easiest\_rules (fewest restrictions), fastest\_payout (quickest time to first withdrawal)

## `winRate` (type: `number`):

Your historical win rate as a decimal for the EV calculator (e.g. 0.55 = 55% win rate). Only used in calculate\_ev mode.

## `avgRR` (type: `number`):

Your average risk:reward ratio for the EV calculator (e.g. 1.5 means you make 1.5x your risk on winning trades). Only used in calculate\_ev mode.

## `discountType` (type: `string`):

Optional keyword to filter promotions results (e.g. 'percent', 'free', 'trial'). Only used in promotions mode.

## `serveMcp` (type: `boolean`):

When enabled, starts an MCP-compatible HTTP server on port 4321. Point Claude, GPT-4, or any MCP client at this actor to get real-time prop firm intelligence in natural language.

## Actor input object example

```json
{
  "mode": "compare",
  "firmName": "",
  "accountSize": 100000,
  "assetClass": "all",
  "priority": "highest_payout",
  "winRate": 0.55,
  "avgRR": 1.5,
  "discountType": "",
  "serveMcp": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("andrew_avina/prop-firm-intel-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("andrew_avina/prop-firm-intel-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call andrew_avina/prop-firm-intel-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=andrew_avina/prop-firm-intel-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Prop Firm Intelligence MCP Server",
        "description": "The prop trading firm industry has exploded to over $3 billion in annual challenge fee revenue. Retail traders spend $100â€“$1,500 per challenge attempt, often without any rigorous analysis of whether the challenge parameters are actually beatable given their strategy's histor...",
        "version": "0.1",
        "x-build-id": "IhBjLdugo8fb13dHS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/andrew_avina~prop-firm-intel-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-andrew_avina-prop-firm-intel-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/andrew_avina~prop-firm-intel-mcp/runs": {
            "post": {
                "operationId": "runs-sync-andrew_avina-prop-firm-intel-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/andrew_avina~prop-firm-intel-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-andrew_avina-prop-firm-intel-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "compare",
                            "firm_rules",
                            "promotions",
                            "calculate_ev"
                        ],
                        "type": "string",
                        "description": "Operation: 'compare' (rank all firms), 'firm_rules' (detailed rules for one firm), 'promotions' (current discounts), 'calculate_ev' (expected value for your stats)",
                        "default": "compare"
                    },
                    "firmName": {
                        "title": "Firm Name",
                        "type": "string",
                        "description": "Prop firm name for firm_rules or calculate_ev mode. Supported: TopstepX, Apex Trader Funding (or Apex), FTMO, MyFundedFutures (or MFF), E8 Markets, The Trading Pit, Funded Trading Plus",
                        "default": ""
                    },
                    "accountSize": {
                        "title": "Account Size (USD)",
                        "minimum": 1000,
                        "type": "integer",
                        "description": "Desired trading account size in USD (e.g. 25000, 50000, 100000, 150000, 200000). Used in compare and calculate_ev modes.",
                        "default": 100000
                    },
                    "assetClass": {
                        "title": "Asset Class",
                        "enum": [
                            "all",
                            "futures",
                            "forex",
                            "stocks",
                            "crypto"
                        ],
                        "type": "string",
                        "description": "Filter firms by supported asset class. Use 'all' to see every firm.",
                        "default": "all"
                    },
                    "priority": {
                        "title": "Ranking Priority",
                        "enum": [
                            "highest_payout",
                            "lowest_cost",
                            "easiest_rules",
                            "fastest_payout"
                        ],
                        "type": "string",
                        "description": "What to optimize for when comparing firms: highest_payout (best % split), lowest_cost (cheapest challenge relative to account size), easiest_rules (fewest restrictions), fastest_payout (quickest time to first withdrawal)",
                        "default": "highest_payout"
                    },
                    "winRate": {
                        "title": "Win Rate (0-1)",
                        "minimum": 0.01,
                        "maximum": 0.99,
                        "type": "number",
                        "description": "Your historical win rate as a decimal for the EV calculator (e.g. 0.55 = 55% win rate). Only used in calculate_ev mode.",
                        "default": 0.55
                    },
                    "avgRR": {
                        "title": "Average Risk:Reward Ratio",
                        "minimum": 0.1,
                        "type": "number",
                        "description": "Your average risk:reward ratio for the EV calculator (e.g. 1.5 means you make 1.5x your risk on winning trades). Only used in calculate_ev mode.",
                        "default": 1.5
                    },
                    "discountType": {
                        "title": "Discount Type Filter",
                        "type": "string",
                        "description": "Optional keyword to filter promotions results (e.g. 'percent', 'free', 'trial'). Only used in promotions mode.",
                        "default": ""
                    },
                    "serveMcp": {
                        "title": "MCP Server Mode",
                        "type": "boolean",
                        "description": "When enabled, starts an MCP-compatible HTTP server on port 4321. Point Claude, GPT-4, or any MCP client at this actor to get real-time prop firm intelligence in natural language.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
