# Crypto Market Scanner & Regime Data (27 assets) (`shicodiez/signal-api-tools`) Actor

Crypto market data for AI agents and MCP: one-call market scan of 27 assets with trend, regime, RSI and rankings, plus per-asset indicators. Pay per call, no API key needed.

- **URL**: https://apify.com/shicodiez/signal-api-tools.md
- **Developed by:** [Sergio](https://apify.com/shicodiez) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 asset data calls

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Crypto Market Scanner & Regime Data (27 assets)

Structured crypto market data for AI agents, MCP clients, and trading systems:
one call returns a complete, machine-readable snapshot instead of raw candles.
No exchange API key or external data subscription is required.

### What it solves

An agent that needs "what is the crypto market doing right now" usually has to
combine an exchange API, an indicator library, a scheduling layer, and its own
prompt logic. This Actor replaces that stack with a single Apify run:

- **27 crypto assets** scanned with the same methodology.
- **One JSON object per run**, with trend, market regime, RSI14, MACD, ATR14,
  Bollinger %B, volatility, 7d/30d returns, and distance to 30d/90d highs and
  lows.
- **Deterministic output** stored both as a dataset item and in the run's
  key-value store under `OUTPUT`, ready for an LLM tool result.
- **Pay per successful event**, so failed calls are not charged.

Use it for market overviews, trend and regime filters, technical screening,
agent tool calls, and MCP workflows.

### Tools and pricing

| Tool | Price per call | What it returns |
| ---- | -------------- | --------------- |
| `market-scan` | **$0.05** | One market-wide snapshot: every supported asset with trend, regime, RSI14, 7d/30d returns, distance to 30d high/low, plus top bullish/bearish and overbought/oversold rankings. |
| `regime` | **$0.01** | Trend (`bullish`/`bearish`/`lateral`), volatility regime, SMA50, SMA50 slope, 30d volatility, and close for one asset. |
| `trend` | **$0.01** | Daily signal (`LONG`/`FLAT`), exposure with volatility control, SMA50, 30d volatility, and close for one asset. |
| `indicators` | **$0.01** | RSI14, MACD(12,26,9), ATR14, Bollinger %B, 7d/30d returns, 30d/90d ranges, and distance to each level. |
| `signal` | **$0.01** | Combined BTC + ETH daily signal with exposure and SMA50 per asset. |
| `sample` | **Free** | One-day-delayed sample for `BTC` or `ETH`: previous trend and regime plus a note. |

Prices are Apify pay-per-event prices in USD. A run is charged only after the
response is valid and stored; a failed run does not charge the paid event.

Supported assets include `BTC`, `ETH`, `SOL`, `XRP`, `BNB`, `DOGE`, `AVAX`,
`LINK`, `SUI`, `ARB`, `UNI`, `NEAR`, `PEPE`, `TRX`, `WLD`, and others for a
total of 27.

### Input

```json
{
  "tool": "market-scan",
  "asset": "BTC"
}
```

| Field | Type | Default | Description |
| ----- | ---- | ------- | ----------- |
| `tool` | string | `market-scan` | One of `market-scan`, `regime`, `trend`, `indicators`, `signal`, `sample`. |
| `asset` | string | `BTC` | Asset symbol such as `BTC`, `ETH`, or `SOL`. Used by `regime`, `trend`, `indicators`, and `sample`; ignored by `market-scan` and `signal`. |

`asset` also accepts pairs such as `BTC/USDT`; the base symbol is used.

### Output

Each run pushes exactly one dataset item and writes the same object to the
`OUTPUT` key-value record. Shortened `market-scan` example:

```json
{
  "id": "market-scan",
  "type": "market",
  "symbol": "ALL",
  "date": "2026-11-08",
  "execution_date": "2026-11-09",
  "asset_count": 27,
  "assets": [
    {
      "asset": "BTC",
      "trend": "bullish",
      "regime": "bullish",
      "rsi14": 55.1,
      "return_7d_pct": 3.2,
      "return_30d_pct": 8.4,
      "distance_to_high_30d_pct": -6.3,
      "distance_to_low_30d_pct": 8.4
    }
  ],
  "rankings": {
    "top_bullish": ["BTC", "SOL"],
    "top_bearish": [],
    "overbought": [],
    "oversold": ["PEPE"]
  }
}
```

Shortened `trend` example:

```json
{
  "id": "trend-btc",
  "type": "trend",
  "symbol": "BTC/USDT",
  "date": "2026-11-08",
  "execution_date": "2026-11-09",
  "signal": "LONG",
  "exposure": 0.75,
  "sma50": 79999.99,
  "volatility_30d": 0.35,
  "close": 75867.59
}
```

### Use from the Apify API

Call the Actor synchronously and get the dataset items in the same response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/shicodiez~signal-api-tools/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tool":"market-scan"}'
```

Or start an asynchronous run:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/shicodiez~signal-api-tools/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tool":"trend","asset":"ETH"}'
```

Then read the results from the returned `defaultDatasetId`:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN"
```

The same payload is also available in the run's key-value store as `OUTPUT`.
Any Apify client library works with the same Actor ID
`shicodiez/signal-api-tools`.

### Use from the Apify MCP server

Connect your MCP client to the hosted Apify MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=actors,storage"
    }
  }
}
```

On first connection, sign in with OAuth, or pass an Apify API token as a
Bearer token. Then ask the agent to run the Actor, for example:

> Run `shicodiez/signal-api-tools` with `{"tool":"market-scan"}` and return the
> dataset items.

The agent uses `call-actor`, then `get-dataset-items` with the returned
`datasetId`. To expose this Actor directly as an MCP tool, use:

```text
https://mcp.apify.com?tools=shicodiez/signal-api-tools
```

This loads a `shicodiez--signal-api-tools` tool with the same input schema.
You can also run the Actor from the Apify Console by opening it and using the
**Input** tab.

### Related project

Source code and the underlying crypto regime engine:
[github.com/Shicodiez/crypto-regime-mcp](https://github.com/Shicodiez/crypto-regime-mcp)

### Disclaimer

All data is provided for informational purposes only and is not financial,
investment, or trading advice. Crypto markets are volatile and past performance
does not guarantee future results. Do your own research and manage risk.

# Actor input Schema

## `tool` (type: `string`):

Signal API tool to call. market-scan returns one market-wide snapshot; regime, trend and indicators target one asset; signal returns the combined BTC+ETH signal; sample returns a free delayed sample.

## `asset` (type: `string`):

Asset symbol such as BTC, ETH or SOL. Used by trend, regime, indicators and sample. Ignored by market-scan and signal.

## Actor input object example

```json
{
  "tool": "market-scan",
  "asset": "BTC"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "asset": "BTC"
};

// Run the Actor and wait for it to finish
const run = await client.actor("shicodiez/signal-api-tools").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 = { "asset": "BTC" }

# Run the Actor and wait for it to finish
run = client.actor("shicodiez/signal-api-tools").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "asset": "BTC"
}' |
apify call shicodiez/signal-api-tools --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shicodiez/signal-api-tools"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/BQlf3qea16A7MVv2e/builds/DlKsEBzfLxefiSfvF/openapi.json