# Crypto Volume & Momentum Scanner - Anomaly Signals (`datasignalslab/crypto-volume-momentum-scanner`) Actor

Crypto volume and momentum scanner: market-wide turnover, momentum and breakout/capitulation anomalies, scored. Pay per scan.

- **URL**: https://apify.com/datasignalslab/crypto-volume-momentum-scanner.md
- **Developed by:** [DataSignals Lab](https://apify.com/datasignalslab) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 market scans

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Crypto Volume and Momentum Scanner: Turnover, Breakouts and Anomalies

**A crypto momentum scanner that scores every coin on turnover and momentum, then ranks the strongest anomalies first.** This crypto screener reads the public CoinGecko markets API, computes turnover (24h volume divided by market cap) plus 1h, 24h and 7d momentum, and classifies each coin as a volume breakout, capitulation, strong weekly momentum or unusual volume at a flat price. You get a ranked signal feed, not a raw market dump.

### Why this is different

Most crypto market endpoints hand back a flat list of prices and volumes and leave the interpretation to you. This crypto momentum scanner builds a signal layer on top of that raw data so the output is already ranked by how unusual each coin is.

- **Turnover as the core metric.** Turnover is 24h trading volume divided by market cap, the single clearest measure of whether a coin is changing hands unusually fast for its size.
- **Adaptive percentile scoring.** Turnover is percentile-ranked within the scanned universe, so the score adapts to current market conditions instead of relying on a fixed threshold that goes stale.
- **Momentum blended in.** A momentum intensity term built from 24h and 7d price change is combined with the turnover percentile into one impact score from 0 to 100.
- **Signal classification.** Each coin is labeled: volume breakout (rising), volume capitulation (falling), strong weekly momentum (up or down), unusual volume (flat price), or normal.
- **Stablecoins filtered out.** Pegged coins are removed by symbol and by price-stability check so their constant high volume does not pollute the ranking.

To be clear about scope: this is a market-data screener built on price and volume. It is not on-chain wallet, whale or "smart money" tracking. There is no clean, free, public source for labeled-wallet flows, so this Actor stays on transparent, reproducible market metrics that anyone can verify.

### Who it's for

- **Crypto traders and quants** who want a ready-made breakout and anomaly screener for watchlists and alerts.
- **Fintech and research apps** that need a scored momentum and volume feed dropped into a product without building the scoring layer.
- **Researchers and analysts** who want a clean, reproducible snapshot of market-wide activity.

### Use cases

- Build a daily or hourly watchlist of coins showing volume breakouts before they trend on social feeds.
- Power a screener tab in a trading app with turnover and momentum already scored and ranked.
- Feed a research notebook a reproducible market snapshot to study how turnover relates to subsequent price action.
- Trigger alerts when any coin in the top universe crosses a chosen impact score.
- Supply an AI agent or automation with structured crypto market signals on demand or on a schedule.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `vsCurrency` | string | `usd` | Quote currency to price against (for example usd, eur, btc). |
| `topN` | integer | `100` | Universe size: how many of the largest coins by market cap to scan (min 10, max 250). Stablecoins are filtered out automatically. |
| `minImpact` | integer | `0` | Only return coins at or above this signal score (0 to 100). For example 70 returns strong anomalies only. 0 returns all. |
| `maxResults` | integer | `50` | Cap on how many ranked coins to return (min 1, max 250). |

### Output

One dataset item per coin, sorted by impact score, strongest first. Example item:

```json
{
  "type": "crypto_signal",
  "vs_currency": "usd",
  "rank": 1,
  "coin_id": "worldcoin-wld",
  "symbol": "WLD",
  "name": "Worldcoin",
  "price": 2.34,
  "market_cap": 2890000000,
  "volume_24h": 612000000,
  "turnover": 0.2118,
  "change_1h": 0.42,
  "change_24h": 8.81,
  "change_7d": 20.14,
  "signal_type": "Volume breakout (rising)",
  "impact": 79,
  "url": "https://www.coingecko.com/en/coins/worldcoin-wld"
}
````

- `turnover` is 24h volume divided by market cap.
- `impact` is the 0 to 100 score described below.
- `signal_type` is one of: Volume breakout (rising), Volume capitulation (falling), Strong weekly momentum (up), Strong weekly momentum (down), Unusual volume (flat price), Normal.
- `change_1h`, `change_24h` and `change_7d` are percentage price changes in the chosen quote currency.

### How the score works

The scoring is transparent and computed directly from market data, so you can reproduce it:

1. **Fetch and filter.** Read the top-N coins by market cap from CoinGecko, then drop stablecoins (matched by known symbols and by a near-1.00 price with tiny 24h change).
2. **Turnover.** For each coin compute turnover = 24h volume / market cap.
3. **Percentile-rank turnover.** Each coin's turnover is ranked as a percentile (0 to 100) within the scanned universe, so high turnover relative to peers scores high.
4. **Momentum intensity.** A momentum term is built as `abs(24h change) * 3 + abs(7d change)`, capped at 100.
5. **Blend into impact.** The final impact score is `0.6 * turnover_percentile + 0.4 * momentum_intensity`, rounded and clamped to 0 to 100.
6. **Classify.** High turnover percentile (>= 70) with positive 24h change becomes a rising breakout; high turnover with negative 24h change becomes capitulation; 7d change of 20% or more (up or down) becomes strong weekly momentum; very high turnover at a flat price becomes unusual volume; everything else is normal.

### Use with AI agents and automation

The output is plain JSON, so this crypto momentum scanner plugs into agent and automation stacks easily:

- **AI agent frameworks.** Call it from LangChain or LlamaIndex tools so an agent can pull live crypto signals as part of a reasoning chain.
- **Apify MCP server.** Expose the Actor through the Apify MCP server so assistants like Claude, ChatGPT or Cursor can run a scan and read results directly.
- **No-code automation.** Wire it into Zapier or Make to push fresh signals into sheets, alerts or chat channels.
- **Webhooks and scheduling.** Trigger on a schedule or via webhook, and have the dataset delivered as JSON on demand or at fixed intervals.

### Pricing

Pay-per-event: one charge per scan. A single run of the scanner equals one `market-scan` charge, regardless of how many coins are returned or how large the universe is. There is no subscription and no per-result metering.

### Data source and compliance

The Actor reads the official CoinGecko markets API (`/coins/markets`), a public, keyless, JSON endpoint of aggregated market data. It processes only public market data such as prices, volumes and market caps. No personal data is collected, scraped or stored, and no login or private API key is required.

### FAQ

**What is turnover?** Turnover is 24h trading volume divided by market cap. High turnover means a coin is changing hands unusually fast for its size, which can be an early sign of a move.

**Why are stablecoins missing?** They are filtered out on purpose. Their constant high volume would otherwise dominate the turnover ranking and bury the real anomalies.

**How current is the data?** CoinGecko updates continuously, and each run reads the latest market snapshot at the moment the scan starts.

**Can an AI agent call this automatically?** Yes. Expose it through the Apify MCP server and an assistant such as Claude, ChatGPT or Cursor can run a scan and read the JSON results without manual steps. It also works as a LangChain or LlamaIndex tool.

**Is this on-chain smart-money data?** No. This is a market-data screener built on price and volume from CoinGecko. It does not track wallets, whales or on-chain flows.

**Can I get only the strongest signals?** Yes. Set `minImpact` (for example 70) to return only coins at or above that score, and use `maxResults` to cap the list length.

***

*Keywords: crypto momentum scanner, crypto screener, volume turnover, volume breakout, unusual volume, altcoin screener, CoinGecko API, crypto signals, crypto market data, crypto anomaly detection.*

***

**Note:** Provided as data for research, screening and monitoring, not investment advice. Crypto is volatile; historical patterns do not guarantee future results.

# Actor input Schema

## `vsCurrency` (type: `string`):

Currency to price against (e.g. usd, eur, btc).

## `topN` (type: `integer`):

How many of the largest coins to scan (stablecoins are filtered out automatically).

## `minImpact` (type: `integer`):

Only return coins at or above this signal score (e.g. 70 = strong volume/momentum anomalies). 0 = all.

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

Cap on how many ranked coins to return.

## Actor input object example

```json
{
  "vsCurrency": "usd",
  "topN": 100,
  "minImpact": 0,
  "maxResults": 50
}
```

# 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("datasignalslab/crypto-volume-momentum-scanner").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("datasignalslab/crypto-volume-momentum-scanner").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 datasignalslab/crypto-volume-momentum-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datasignalslab/crypto-volume-momentum-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto Volume & Momentum Scanner - Anomaly Signals",
        "description": "Crypto volume and momentum scanner: market-wide turnover, momentum and breakout/capitulation anomalies, scored. Pay per scan.",
        "version": "0.1",
        "x-build-id": "ptdhplUltPK3oEsZA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datasignalslab~crypto-volume-momentum-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datasignalslab-crypto-volume-momentum-scanner",
                "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/datasignalslab~crypto-volume-momentum-scanner/runs": {
            "post": {
                "operationId": "runs-sync-datasignalslab-crypto-volume-momentum-scanner",
                "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/datasignalslab~crypto-volume-momentum-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-datasignalslab-crypto-volume-momentum-scanner",
                "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": {
                    "vsCurrency": {
                        "title": "Quote currency",
                        "type": "string",
                        "description": "Currency to price against (e.g. usd, eur, btc).",
                        "default": "usd"
                    },
                    "topN": {
                        "title": "Universe size (top N by market cap)",
                        "minimum": 10,
                        "maximum": 250,
                        "type": "integer",
                        "description": "How many of the largest coins to scan (stablecoins are filtered out automatically).",
                        "default": 100
                    },
                    "minImpact": {
                        "title": "Minimum impact score (0-100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return coins at or above this signal score (e.g. 70 = strong volume/momentum anomalies). 0 = all.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max coins returned",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Cap on how many ranked coins to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
