# Crypto Reality Check (`zaffy_93/crypto-reality-check`) Actor

Before acting on a crypto move, whale trade or headline, ask: is it real or noise? Pay-per-call verdicts for AI agents from 24/7 Binance and Hyperliquid monitoring, each sealed and scored in public.

- **URL**: https://apify.com/zaffy_93/crypto-reality-check.md
- **Developed by:** [MohammedZafer Memon](https://apify.com/zaffy_93) (community)
- **Categories:** Agents, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 full check before actings

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 Reality Check

Before your agent acts on a crypto price move, a whale trade or a headline, ask one question: **is it real, or noise?**

Answers come from a monitor that records Binance spot and futures, Hyperliquid and 31 news sources every minute,
24/7. Each answer gives a plain verdict to act on, the numbers behind it, and a seal. The chances it states are
scored in public afterwards, including when they turn out wrong.

### Questions and prices

| `tool` | Answers | Input | Price per answer |
|---|---|---|---|
| `full_check` | **One call before acting on a token:** its move, its whales and its news together, and whether they agree | `token` | $0.02 |
| `market_mood` | What is the whole crypto market doing right now? | none | $0.002 |
| `check_move` | Is this token's last-hour move its own or the market's, how unusual is it, and did moves like it keep going? | `token` | $0.01 |
| `whale_flow` | What did the biggest traders do in this token in the last hour, by venue? | `token` | $0.01 |
| `check_news` | Is this headline actually moving the price, or already priced in? | `token` and/or `query` | $0.01 |
| `signal_truth` | Does this kind of signal work, measured on real outcomes? | optional `signal`, `direction` | $0.005 |

You pay only for answers. A question it cannot answer is never charged (see below).

### Example

Input:

```json
{ "tool": "check_move", "token": "BMT" }
```

Output (a real answer, shortened):

```json
{
  "tool": "check_move",
  "as_of": "2026-10-23T15:34:00+05:30",
  "data_age_s": 88,
  "token": "BMT",
  "move_1h_pct": -10.03,
  "own_part_pct": -8.55,
  "market_part_pct": -1.47,
  "normal_swing_1h_pct": 1.62,
  "vs_normal_swing": 6.2,
  "verdict": { "driver": "own", "size": "extreme", "follow_through": "no_edge" },
  "history": {
    "case": "BMT 1-hour fall of 5%+",
    "episodes": 53,
    "next_hour_continued": 0.434,
    "range_99_5": [0.264, 0.621],
    "any_hour_same_direction": 0.473,
    "follow_through": "no_edge"
  },
  "chance_next_hour_continues": 0.434,
  "plain": "Mostly BMT's own move (-10.0% in 1 hour, -8.6 points its own): 6.2x its normal hourly swing, extreme. After 53 drops of 5%+ in its history, the next hour went down 43% of the time, against 47% for any hour: no edge in following it.",
  "snapshot_seal": "1f2fddf4d21c267d57813b19a8576ddffe1d2003d5d66c952b4739f0abd3ff35",
  "price_usd": 0.01,
  "charged": true
}
```

Every answer has `verdict` (short codes for logic) and `plain` (one or two sentences for people).

`full_check` returns the three answers under `move`, `whales` and `news`, plus `verdict.overall`
(`something_unusual` or `nothing_unusual`) and `verdict.agreement`. The agreement is `aligned_up`,
`aligned_down`, `conflicting` or `no_clear_side`. A price move within its normal swing takes no side.

### Use it from any AI agent (MCP)

Agents on Apify's MCP server can find this Actor with `search-actors` and run it with `call-actor`, with no setup.
To give your agent these tools directly, add this server to Claude, ChatGPT, Cursor or any MCP client:

```json
{
  "mcpServers": {
    "crypto-reality-check": {
      "url": "https://mcp.apify.com?tools=zaffy_93/crypto-reality-check"
    }
  }
}
```

On first use the client signs in to Apify, or you can pass an `Authorization: Bearer <APIFY_TOKEN>` header. From code,
call the Actor's API: `POST https://api.apify.com/v2/acts/zaffy_93~crypto-reality-check/run-sync-get-dataset-items`
with the input JSON as the body. The answer comes back in the same response.

### Inputs

- `tool` (required): one of the six above.
- `token`: a ticker such as `BTC`, `ETH` or `SOL`. `BTCUSDT`, `$BTC` and `btc` work too. `check_move` covers the
  top 50 Binance tokens by traded value. `whale_flow` also covers the coins watched for whale orders on Hyperliquid
  and Binance futures.
- `query`: for `check_news`, words from a headline, such as `ETF approval`.
- `signal`: for `signal_truth`, one of `move_5m`, `move_1h`, `btc_move`, `volume_spike`, `whale_spot`, `whale_futures`,
  `whale_hyperliquid`, `liquidation`, `market_liquidation`, `funding_extreme`, `open_interest` or `news`. Leave it
  empty for the whole table.
- `direction`: for `signal_truth`, `up` or `down`. Leave it empty for both.

### When you are not charged

The run still succeeds and returns one item with `"charged": false` and an `error` saying why, when:

- the tool, token or signal is unknown;
- the market data is more than 10 minutes old (the service refuses rather than sell stale data);
- the data cannot be loaded;
- your run's spending limit is below the answer's price.

### How to check it is honest

- **Seals.** Every answer names `snapshot_seal`. Each minute's market snapshot is sealed as
  sha256(previous seal + sha256 of the snapshot), so a past snapshot cannot be changed without breaking every seal
  after it. The answers are computed from that snapshot alone.
- **Public record.** At the top of every hour, the chance `check_move` states is recorded for every tracked token,
  whether anyone bought that answer or not, and scored an hour later. Calibration and the day-by-day seals are here:
  https://api.apify.com/v2/key-value-stores/Kfaru3CN4RdvD9Veg/records/scoreboard?signature=e9OKp2wi1liyUTe5e1Z1
- **Failing signals are labelled failing.** `signal_truth` reports PROVEN, PROVISIONAL, UNPROVEN or FAILED, using
  99.5% bounds over independent episodes. At launch, most signals are coin flips and one reliably reverses. The
  service says so.

### Need the raw numbers?

[Crypto Market Data for AI Agents](https://apify.com/zaffy_93/crypto-market-data) gives plain live data at $0.001 a
call: prices, funding and open interest, every Binance futures liquidation, whale orders, news, Fear & Greed and order
books, refreshed every minute.

### Limits

- Chances are historical rates from this market's own past, not predictions or advice.
- With 50 tokens and several move sizes, a few "continues" or "reverses" labels will be luck even at 99.5%. The
  public record shows which ones hold up.
- Data updates once a minute. `data_age_s` in every answer says how old it is.
- Rates come from hourly candles. Tokens newly added to the top 50 say "no price history yet" until it is loaded.
- Public market data only: no accounts, keys or private data are involved.

# Actor input Schema

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

full_check ($0.02): one call before acting on a token: its move, its whales and its news together, and whether they agree (needs token). market_mood ($0.002): what the whole market is doing now. check_move ($0.01): is this token's last-hour move its own, unusual, and worth chasing (needs token). whale_flow ($0.01): what the biggest traders did in this token in the last hour (needs token). check_news ($0.01): is a headline actually moving the price (token and/or query). signal_truth ($0.005): does a kind of signal work, measured on real outcomes (optional signal and direction).

## `token` (type: `string`):

Ticker such as BTC, ETH or SOL (USDT pairs and $BTC are accepted too). Needed for full_check, check_move and whale_flow; optional filter for check_news.

## `query` (type: `string`):

For check_news: words from the headline, for example 'ETF approval' or 'exchange hack'. Optional.

## `signal` (type: `string`):

For signal_truth. Leave empty for the full table of all signals.

## `direction` (type: `string`):

For signal_truth: up or down. Leave empty for both.

## Actor input object example

```json
{
  "tool": "market_mood",
  "token": "BTC"
}
```

# Actor output Schema

## `answer` (type: `string`):

No description

## `output` (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 = {
    "tool": "market_mood",
    "token": "BTC"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaffy_93/crypto-reality-check").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 = {
    "tool": "market_mood",
    "token": "BTC",
}

# Run the Actor and wait for it to finish
run = client.actor("zaffy_93/crypto-reality-check").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 '{
  "tool": "market_mood",
  "token": "BTC"
}' |
apify call zaffy_93/crypto-reality-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zaffy_93/crypto-reality-check"
        }
    }
}
```

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/mCrWHdMBeKYXJvwhU/builds/4RfhrgMRlZMjxblFF/openapi.json