# Nyxina — Crypto Watchlist Screener, calibrated & graded (`nyxina/crypto-watchlist-screener`) Actor

An honest crypto watchlist: an ML model predicts which perps are likeliest to pop +10%+ in 24h, each with a calibrated probability that IS the real hit rate — never a made-up '99'. +10% is the floor; every pick graded in public the next day, misses included.

- **URL**: https://apify.com/nyxina/crypto-watchlist-screener.md
- **Developed by:** [Nyxina](https://apify.com/nyxina) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 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

## Nyxina — Crypto Watchlist Screener

**An honest crypto watchlist — predicted today, graded in public tomorrow. The score you see is the real, measured hit rate, never a made-up '99'.**

A ranked list **predicting** which crypto perps are most likely to touch
**+10% or more in the next 24h** — each with an honest, calibrated probability.
And +10% is the *floor*, not the ceiling: we keep grading every pick at **48h
and 72h**, where the real winners tend to run much further. It's a *forecast*,
not a report of what already moved — a daily screener for traders, not a live
ticker for scalpers.

Pick the **edition** that fits your timezone — **00:00 / 06:00 / 12:00 / 18:00
UTC** (Asia morning → US afternoon). Each is its own independently backtested,
separately calibrated list, refreshed once a day at its anchor. It's ready a few
minutes later, so **pull it any time from :30 past the hour** (00:30 / 06:30 /
12:30 / 18:30 UTC) — no need to check before then. Same engine, four snapshots of
the day; grab the one nearest when you trade.

Not a scrape-and-rank feed: every score comes from a researched, back-tested
model — out-of-sample across every market regime, calibrated so the number *is*
the real hit rate.

> 🎁 **Free while we launch.** Pull it as much as you like, no charge — we're
> building the public track record first. Pricing arrives later (you'll see it
> here when it does), so early users get in free.

### Why Nyxina

- 🚫 **Not a top-gainers list.** That's free on any exchange — and it's
  *backwards*. Our model gives a coin's 24h pump **almost zero weight** and
  penalizes ones already stretched from their lows; it ranks on whether +10% is
  likely **next** — from volatility and each coin's *own* history of moving. So a
  red coin near its low routinely outranks a green one that already ran, and a
  top gainer only makes the cut **if the math still likes it.**
- 📋 **No code, no setup.** Read it as a table right in your browser, or export
  to **Excel / CSV** in one click — or **Schedule** it to run itself daily.
  Builders get clean JSON/API too. Same data, your format.
- 🎯 **Calibrated.** A coin showing **38** hit +10% in ~38% of similar past
  cases. Nothing here shows 99 — other screeners' "99" is a marketing number.
- 🧾 **Receipts.** The 00:00 edition is graded every day, in public, on the
  [Telegram ledger](https://t.me/nyxina_crypto_screener) — **misses included**,
  nothing deleted — and each day's full list is **sha256-committed when posted**,
  so the next-day reveal provably matches (no quietly editing history). That
  daily public scorecard is the standard of proof; every edition runs the same
  engine, each calibrated to its own anchor.
- 📊 **Audited.** Out-of-sample across every regime, delisted coins included.
- 🧠 **Model-driven, kept honest.** A machine-learning model — not hand-tuned
  rules — recalibrated against real outcomes as the live record grows. The
  backtest never stops.
- 💸 **Cheap, on demand.** A fresh list lands once a day per edition — pull one
  when you're about to trade and casual use costs next to nothing. No reason to
  spam it; one daily glance keeps you on top of the board.

### Who it's for

- **Busy traders.** One glance a day instead of twelve chart hours. Check the
  list with your morning coffee, pick, size, set your exit clock — then go
  live your life. The math favors patience, not screen-watching: winners
  typically need hours to a day, not minute-by-minute babysitting.
- **Beginners.** Don't know where to start? Use the daily list as your
  watch-and-learn feed. The graded history shows what a 38 really means, and
  the risk tags teach you what danger looks like before it costs you.
- **Builders.** Clean JSON via API — pipe the list straight into your own
  bot, dashboard, or sheet.

### No code needed — and why it's on Apify

You don't need to be a developer:

1. Click **Start** — a simple form (edition/timezone, list size, tags on/off).
2. Read the results as a **table**, or export to **CSV / Excel** in one click.
3. Want it daily at your hour? Hit **Schedule** and it runs itself.

Builders get the same data as clean **JSON / API** — pipe it into a bot, sheet,
or dashboard. Same data, your format.

**Why Apify, not our own website?** Because you shouldn't have to trust *us*.
Apify is an established, public automation platform — the screener runs there in
a sandbox, with access and billing handled by a neutral third party, so you
never hand details to, or run code from, an anonymous site we control. It's a
public listing (run stats and reviews in the open), and the track record is
fully public: every pick is graded the next day on the
[free Telegram ledger](https://t.me/nyxina_crypto_screener) — misses included —
and each day's list is **sha256-committed when posted**, so the reveal provably
can't be edited. *Don't trust, verify.*

### The numbers

| Tier | +10% in 24h | in 72h | random coin |
|---|---|---|---|
| Top pick | **65%** | **75%** | 11% |
| Top 3 | 64% | 74% | 11% |
| Top 10 | 52% | 66% | 11% |
| Top 30 | 41% | 58% | 11% |

The edge held in **every regime** we tested. And **+10% is the floor we grade, not
a cap** — winners don't stop there (median on the sharp end tops ~+30% within
72h, 1 in 10 doubles). The odds are measured from **each edition's snapshot price**
(00:00 / 06:00 / 12:00 / 18:00 UTC — the anchor you're viewing, not always midnight),
so getting in below it only widens your gain.

**Board read.** Each edition carries a one-line `board` signal — how strong
today's board is. We rank the top 10 **every day, whatever the regime** — so on a
**quiet board** those 10 are inherently weaker and more of them will miss (~41% hit
vs ~56% on a **strong board**). The badge says so up front: **size lighter when it's
quiet, lean in when it's strong.** We'd rather flag a weak day than hide it — the
misses on a quiet day are expected, not a surprise. Free on every surface.

### We use it too

This isn't a scorer built only to sell — the same engine runs in our own live
crypto trading every day; we wouldn't stake our own money on a number we didn't
trust. Honesty cuts both ways, though: this is the **watchlist**, not our exact
trades — our live trading adds its own entry and risk filters on top (some
high-scorers we *watch* but don't *take*), and the edge is in how you **enter,
exit, and size**, not the score alone. That entry read is what the per-coin
**`tip`** hands you. So you get the genuinely hard part — where to look, with
real odds — and we stay upfront that the trade is yours.

### Each row

`rank` · `symbol` · `score` (calibrated %) · `price_at_score` ·
`tags` (risk chips: `hot`, `stretched`, `beaten-down`, `falling`, ...) ·
`tip` (a one-line entry read) ·
`venues` (also on Bybit / OKX / Hyperliquid / Coinbase) · `day` (the edition's UTC anchor)

Tags warn, they don't censor — a hot coin with a warning chip can still be
the move of the day. Read them as context.

The **`tip`** is a soft, plain-language read on *entry timing* — the gap between
"likely to move" and "a good entry right now" (the same thing our own trading
weighs). It's **guidance, not a graded number**: the `score` is the measured edge,
the `tip` is just context. A clean coin gets a green light; a coin that's already
running gets a "don't chase" nudge. Your call, always.

### Use it right

1. **A watchlist, not a buy list** — a daily shortlist to *watch*, never a
   "buy these." We give you where to look and the real odds; the entry, exit,
   and sizing are yours.
2. **Spread your picks** — 63% still misses 1 in 3.
3. **Top rank ≠ best trade** — check the tags.
4. **Survive the dip** — winners often go −5..−15% first. Size for it.
5. **Give it a day** — median winner needs ~11h; 3 in 10 need more than a
   day. Selling red at hour 2 donates winners.
6. **Don't FOMO — enter cold.** The odds are measured at our snapshot price, so
   enter near it or on the dip and find your moment; chasing a coin that already
   ran another leg pays up and wrecks the very odds you came for. And red ≠
   missed — fresh-and-red is the *designed* shape, not a failed trade.
7. **Mind the macro — then use it.** The model reads each coin's *own* behavior,
   not the headlines, so it can't see a Fed print or a market-wide BTC flush
   coming — in a broad risk-off the hit rate dips (the *ranking* holds, the
   *regime* doesn't). So size down or sit out the falling knife. **But a crash
   isn't the end of the list — it's the setup:** flushes reset coins to oversold,
   and the rebound is where the strongest names rip hardest. We predict *coins*,
   not *crashes* — yet timed right (once it's basing, not mid-drop), a flush is
   *fuel*, and this is the list that tells you which names to load.

---

*Crypto derivatives are extremely risky. Not financial advice. Past
performance doesn't guarantee future results. DYOR.*

# Actor input Schema

## `edition` (type: `string`):

Which daily edition to pull — pick the anchor nearest your trading session. Each is independently backtested and calibrated; the score is the real hit rate at that anchor. New list per anchor each day.
## `listSize` (type: `integer`):

How many top-ranked coins to return (1-30).
## `includeTags` (type: `boolean`):

Include the risk/context tag chips for each row.

## Actor input object example

```json
{
  "edition": "00",
  "listSize": 10,
  "includeTags": true
}
````

# 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("nyxina/crypto-watchlist-screener").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("nyxina/crypto-watchlist-screener").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 nyxina/crypto-watchlist-screener --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nyxina — Crypto Watchlist Screener, calibrated & graded",
        "description": "An honest crypto watchlist: an ML model predicts which perps are likeliest to pop +10%+ in 24h, each with a calibrated probability that IS the real hit rate — never a made-up '99'. +10% is the floor; every pick graded in public the next day, misses included.",
        "version": "0.2",
        "x-build-id": "YeQlf1udljt2gWwGw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nyxina~crypto-watchlist-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nyxina-crypto-watchlist-screener",
                "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/nyxina~crypto-watchlist-screener/runs": {
            "post": {
                "operationId": "runs-sync-nyxina-crypto-watchlist-screener",
                "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/nyxina~crypto-watchlist-screener/run-sync": {
            "post": {
                "operationId": "run-sync-nyxina-crypto-watchlist-screener",
                "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": {
                    "edition": {
                        "title": "Edition (UTC anchor)",
                        "enum": [
                            "00",
                            "06",
                            "12",
                            "18"
                        ],
                        "type": "string",
                        "description": "Which daily edition to pull — pick the anchor nearest your trading session. Each is independently backtested and calibrated; the score is the real hit rate at that anchor. New list per anchor each day.",
                        "default": "00"
                    },
                    "listSize": {
                        "title": "List size",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many top-ranked coins to return (1-30).",
                        "default": 10
                    },
                    "includeTags": {
                        "title": "Include risk tags",
                        "type": "boolean",
                        "description": "Include the risk/context tag chips for each row.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```