# Polymarket Whale Alerts & Odds Movement Scanner (`plus_ev/polymarket-intelligence`) Actor

Scan Polymarket for whale trades, odds movement, 24h volume spikes, high-liquidity markets, and keyword-matched opportunities.

- **URL**: https://apify.com/plus\_ev/polymarket-intelligence.md
- **Developed by:** [Aar Co](https://apify.com/plus_ev) (community)
- **Categories:** News, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.25 / completed scan

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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

## Polymarket Whale Alerts & Odds Movement Scanner

Find unusual activity on Polymarket without manually refreshing market pages.

This Actor scans active Polymarket markets and recent trades to surface structured signals such as whale trades, large 24h volume, meaningful odds movement, and high-liquidity markets that match your keywords.

### What it is useful for

- Monitoring markets tied to themes like crypto, elections, macro, AI, sports, or breaking news
- Finding large trades that may be worth reviewing
- Spotting active/high-liquidity markets faster
- Creating scheduled prediction-market research feeds
- Sending structured market signals into dashboards, agents, spreadsheets, Slack, Telegram, or webhooks

### Signals detected

| Signal | What it means |
|---|---|
| Whale trade | A recent trade exceeds your configured USD threshold |
| Odds movement | A market moved by more than your configured 24h percentage-point threshold |
| Volume spike | 24h market volume exceeds your configured threshold |
| High liquidity | Market liquidity and volume clear your filters |
| New/discovered market | Active keyword-matched market worth reviewing |

### Example use cases

- “Show me large Bitcoin-related Polymarket trades.”
- “Find active Fed / inflation / election markets.”
- “Monitor markets with meaningful odds movement.”
- “Run this every hour and export results to a dataset or webhook.”

### Example input

```json
{
  "keywords": ["Bitcoin", "Fed", "Trump", "election"],
  "signalTypes": ["whale_trade", "odds_movement", "volume_spike", "high_liquidity"],
  "whaleTradeThresholdUsd": 5000,
  "oddsMoveThresholdPct": 5,
  "volumeSpikeThresholdUsd": 50000,
  "minLiquidityUsd": 5000,
  "maxResults": 250
}
````

### Example output

```json
{
  "source": "polymarket",
  "signalType": "whale_trade",
  "marketTitle": "Will Bitcoin hit $150k in 2026?",
  "marketUrl": "https://polymarket.com/market/...",
  "side": "BUY",
  "outcome": "Yes",
  "price": 0.31,
  "tradeValueUsd": 12500,
  "wallet": "0x...",
  "reason": "BUY Yes worth approximately $12,500.",
  "detectedAt": "2026-07-06T00:00:00Z"
}
```

### Pricing suggestion

Launch pricing: **$0.25 per completed scan**.

For Apify pay-per-event monetization, configure the event name:

```text
scan_completed
```

This is intentionally low-friction so users can test scheduled scans, keyword watchlists, and alert workflows without committing to a subscription.

### Notes and limitations

- This Actor is for research and monitoring only.
- It does not place trades.
- It does not provide financial advice.
- “Whale” thresholds are configurable and based on observed trade value.
- Cross-market Kalshi comparison is planned for a future version, not included in this MVP.

### Output

Results are saved to the default Apify dataset as structured JSON records, ready for API use, export, scheduling, or webhook automation.

# Actor input Schema

## `keywords` (type: `array`):

Only return markets/trades matching any keyword in title, slug, event, or description. Empty = all.

## `signalTypes` (type: `array`):

Signals to detect.

## `minVolumeUsd` (type: `integer`):

Minimum lifetime market volume in USD for high-liquidity signals.

## `minLiquidityUsd` (type: `integer`):

Minimum market liquidity in USD for high-liquidity and discovery signals.

## `oddsMoveThresholdPct` (type: `number`):

Minimum absolute 24-hour price move in percentage points for odds movement signals.

## `whaleTradeThresholdUsd` (type: `integer`):

Minimum approximate trade value in USD for whale trade alerts.

## `volumeSpikeThresholdUsd` (type: `integer`):

Minimum 24-hour market volume in USD for volume spike signals.

## `lookbackHours` (type: `integer`):

Trade lookback window in hours. Current MVP scans recent Polymarket trade endpoint results.

## `maxMarkets` (type: `integer`):

Maximum active Polymarket markets to scan.

## `maxTrades` (type: `integer`):

Maximum recent Polymarket trades to scan.

## `maxResults` (type: `integer`):

Maximum dataset items to output.

## `includeClosedMarkets` (type: `boolean`):

Whether to include closed markets when scanning.

## Actor input object example

```json
{
  "keywords": [
    "AI",
    "Fed",
    "Trump",
    "Bitcoin",
    "election",
    "inflation"
  ],
  "signalTypes": [
    "whale_trade",
    "odds_movement",
    "volume_spike",
    "high_liquidity",
    "new_market"
  ],
  "minVolumeUsd": 10000,
  "minLiquidityUsd": 5000,
  "oddsMoveThresholdPct": 5,
  "whaleTradeThresholdUsd": 5000,
  "volumeSpikeThresholdUsd": 50000,
  "lookbackHours": 24,
  "maxMarkets": 250,
  "maxTrades": 500,
  "maxResults": 250,
  "includeClosedMarkets": 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("plus_ev/polymarket-intelligence").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("plus_ev/polymarket-intelligence").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 plus_ev/polymarket-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polymarket Whale Alerts & Odds Movement Scanner",
        "description": "Scan Polymarket for whale trades, odds movement, 24h volume spikes, high-liquidity markets, and keyword-matched opportunities.",
        "version": "0.1",
        "x-build-id": "dGTt2etaVtSRH9YVz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/plus_ev~polymarket-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-plus_ev-polymarket-intelligence",
                "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/plus_ev~polymarket-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-plus_ev-polymarket-intelligence",
                "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/plus_ev~polymarket-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-plus_ev-polymarket-intelligence",
                "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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Only return markets/trades matching any keyword in title, slug, event, or description. Empty = all.",
                        "default": [
                            "AI",
                            "Fed",
                            "Trump",
                            "Bitcoin",
                            "election",
                            "inflation"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "signalTypes": {
                        "title": "Signal types",
                        "type": "array",
                        "description": "Signals to detect.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "whale_trade",
                                "odds_movement",
                                "volume_spike",
                                "high_liquidity",
                                "new_market"
                            ]
                        },
                        "default": [
                            "whale_trade",
                            "odds_movement",
                            "volume_spike",
                            "high_liquidity",
                            "new_market"
                        ]
                    },
                    "minVolumeUsd": {
                        "title": "Minimum lifetime volume USD",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum lifetime market volume in USD for high-liquidity signals.",
                        "default": 10000
                    },
                    "minLiquidityUsd": {
                        "title": "Minimum liquidity USD",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum market liquidity in USD for high-liquidity and discovery signals.",
                        "default": 5000
                    },
                    "oddsMoveThresholdPct": {
                        "title": "Minimum 24h odds move percentage points",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum absolute 24-hour price move in percentage points for odds movement signals.",
                        "default": 5
                    },
                    "whaleTradeThresholdUsd": {
                        "title": "Whale trade threshold USD",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum approximate trade value in USD for whale trade alerts.",
                        "default": 5000
                    },
                    "volumeSpikeThresholdUsd": {
                        "title": "24h volume spike threshold USD",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum 24-hour market volume in USD for volume spike signals.",
                        "default": 50000
                    },
                    "lookbackHours": {
                        "title": "Trade lookback hours",
                        "minimum": 1,
                        "maximum": 168,
                        "type": "integer",
                        "description": "Trade lookback window in hours. Current MVP scans recent Polymarket trade endpoint results.",
                        "default": 24
                    },
                    "maxMarkets": {
                        "title": "Max markets to scan",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum active Polymarket markets to scan.",
                        "default": 250
                    },
                    "maxTrades": {
                        "title": "Max recent trades to scan",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum recent Polymarket trades to scan.",
                        "default": 500
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum dataset items to output.",
                        "default": 250
                    },
                    "includeClosedMarkets": {
                        "title": "Include closed markets",
                        "type": "boolean",
                        "description": "Whether to include closed markets when scanning.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
