# Crypto Signal Checker (`genkenobi/crypto-signal-checker`) Actor

AI checks crypto futures signals against BingX trend, news and Bybit liquidations. No orders. Free and paid Apify accounts supported, subject to model access. Assessment, start and separate model charges may apply; see Pricing.

- **URL**: https://apify.com/genkenobi/crypto-signal-checker.md
- **Developed by:** [Burhan Hayber](https://apify.com/genkenobi) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.00 / 1,000 signal assessments

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 Signal Checker

![Crypto Signal Checker logo](https://images.apifyusercontent.com/oKDpL_uI_Szh4mL0pmllE90CPUwMMIgyUW45JeGkwmQ/cb:1/aHR0cHM6Ly9hcGlmeS1pbWFnZS11cGxvYWRzLXByb2QuczMudXMtZWFzdC0xLmFtYXpvbmF3cy5jb20vTWwxaWE0YXFwR0pDTzFaNHMtYWN0b3ItYml3MnBndWRmNENQeG5Pc0MtaTJQcmZvdG5sRC1leGVjLTNiYTdiODA4LTM1OTEtNGRkOS04OWRmLTAyODg0NzQ3NmFhYi5wbmc.png)

**Turn a structured crypto signal into a clear, evidence-backed assessment.**

- **Live market context:** check current BingX prices and the hourly trend.
- **News context:** recent coin and market headlines are provided to the model as unverified sources when the model is called.
- **Portfolio context:** optionally add your existing positions; no exchange connection or orders are needed.
- **Liquidation context:** prior four hours of Bybit liquidation totals when complete, fresh coverage is available.
- **AI assessment:** receive a structured Qwen decision with reasons and available evidence.
- **Ready for workflows:** use the Actor in Apify, via API, or with MCP.
- **No OpenRouter key required:** model usage is billed separately to the running Apify account.

Assess one structured USDT perpetual futures signal against recent BingX market data and Qwen. Get an `approve`, `reject`, or `unknown` result with the available evidence and a short reason. The Actor does not place orders, predict profits, or assess whether a trade is suitable for you.

### What it checks

1. Validates the symbol, direction, prices, and signal geometry. LONG targets must be above the entry in ascending order, with the stop below it; SHORT targets must be below the entry in descending order, with the stop above it.
2. Retrieves closed hourly candles and recent trades from BingX USDT perpetual markets. It requires at least 50 consecutive hourly candles and a recent trade no more than 120 seconds old.
3. Rejects a signal if the current price is at or beyond its stop or first target. LONG requires a rising H1 close sequence and EMA20 above EMA50; SHORT requires a falling sequence and EMA20 below EMA50. An unclear trend returns `unknown`.
4. When those checks pass, sends the signal and market evidence to `qwen/qwen3.8-max-0902` through OpenRouter for a conservative assessment. It checks a fresh trade again before returning the model's result.

`approve` is the model's assessment after the checks above, not a trade instruction or a guarantee. `reject` indicates a failed price or trend check, or a model rejection. `unknown` means the Actor could not make an assessment, for example because the input geometry is invalid, market data is missing or stale, or the model request or response failed. Invalid input can also fail the run before a dataset item is created. Model confidence is an uncalibrated judgment, not a probability of profit.

The Actor does not have channel history. News, user-provided positions and Bybit liquidations are included only when the model stage is reached; unavailable sources are explicitly marked. Liquidations cover Bybit only and are unavailable when the collector has gaps or stale coverage. Positions are not verified against an exchange, and news headlines are not verified facts. It checks the current price, but it does not know when the signal was published or whether a stop or target was reached earlier. It reports the current price distance from the planned entry; it does not verify execution, liquidity, or fees. It supports only BingX USDT perpetual markets. Market conditions can change immediately after the assessment.

### Input

Provide a base `symbol` of 2–20 letters or digits, `direction` (`LONG` or `SHORT`), positive numeric `entry` and `stop` prices, and one to ten ordered numeric `take_profits`. Prices are in USDT. Optionally add `original_text` (up to 4,000 characters) for the model to compare against the structured fields. This comparison is model-based and is not independently verified. The Actor does not extract prices from free text.

Free and paid Apify accounts can run the Actor, subject to available credit and Apify access restrictions. Free-plan model access may be blocked by Apify anti-fraud protections. Apify currently lists a 10x OpenRouter markup for free accounts; check its current pricing. No separate OpenRouter account or API key is needed.

Optionally provide `positions`, an array of up to 50 objects such as `{"symbol":"BTC","direction":"LONG"}`. These entries are user-supplied and not verified; an omitted array means positions are unknown. Enter an empty array only if there are no open positions. Values are sent to the model and stored in the output. Never include account credentials or other sensitive details.

Example values below are hypothetical and are not a trade recommendation:

```json
{
  "signal": {
    "symbol": "BTC",
    "direction": "LONG",
    "entry": 100000,
    "stop": 98000,
    "take_profits": [102000, 104000],
    "original_text": "BTC long, entry 100000, stop 98000, targets 102000 and 104000"
  }
}
```

### Output

The default dataset contains one item when an assessment completes. Depending on the outcome, it includes `status`, `reason`, `as_of`, available `sources`, the normalized `signal`, `market`, and an `assessment` containing the model's decision, confidence, regime, risks, and short reasoning. An `error` code may explain an `unknown` result. Fields depend on how far the checks progressed.

### Costs and data handling

The result fee applies per `approve` or `reject`; see the Pricing tab for the current amount. An `unknown` result has no assessment fee. Apify also charges the Actor start event ($0.00005 per GB, minimum one event), including for an `unknown` result or an ineligible run. Platform usage is included in the event pricing for standard runs. Model requests through Apify's OpenRouter proxy are charged separately to the running Apify account, including when the result is `unknown`; a signal rejected before that stage does not make a model request. Check the current prices and your account limits before running.

The Actor sends the symbol to BingX to fetch market data and, when the model stage is reached, searches Google News for recent headlines and fetches liquidation aggregates from the developer's read-only service. At that stage, the structured signal, optional original text and positions, market data, headlines, liquidation data, and evidence limitations are sent via Apify to OpenRouter. Apify stores run inputs according to its storage settings. The output contains the structured signal and supplied positions but does not copy the original text into the result dataset. Avoid putting credentials or sensitive information in signal fields. Protect your Apify credentials and review the providers' data policies.

### API and MCP

You can run the Actor from Apify Console or via the [Apify API](https://docs.apify.com/api/v2/actor-run-sync-get-dataset-items-post): POST the input JSON to `https://api.apify.com/v2/acts/genkenobi~crypto-signal-checker/run-sync-get-dataset-items` with your Apify authorization. Keep tokens out of URLs, logs, and shared examples.

For AI agents, connect to the [Apify MCP server](https://docs.apify.com/mcp), call `genkenobi/crypto-signal-checker` with the same input, and retrieve the dataset items from the resulting run. Use an authenticated client and treat its handling of input secrets as part of your security setup.

### Example cost for 100 direct assessments

For 100 direct `approve` or `reject` results, multiply the current assessment price on the Pricing tab by 100, then add at least $0.005 for 100 Actor starts at the listed minimum of $0.00005 each. Model usage is billed separately whenever the model is called. An `unknown` result has no assessment fee, but may still incur start and model charges. Calling through the Crypto MCP Toolkit can add its own start fee. Check current prices, free-plan markups and your account limits.

# Actor input Schema

## `signal` (type: `object`):

Enter one USDT perpetual signal. Model charges are billed separately via Apify; free-plan model access may be restricted and can cost more. Signal values and optional text are sent to OpenRouter.

## `positions` (type: `array`):

Manually entered existing positions, not verified against an exchange. At most 50 objects: {"symbol": "BTC", "direction": "LONG"}. Sent to the model when used. No trading access is requested.

## Actor input object example

```json
{
  "signal": {
    "symbol": "BTC",
    "direction": "LONG",
    "entry": 100000,
    "stop": 98000,
    "take_profits": [
      102000
    ]
  }
}
```

# Actor output Schema

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

Dataset items with status, reason, sources and available market evidence.

# 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 = {
    "signal": {
        "symbol": "BTC",
        "direction": "LONG",
        "entry": 100000,
        "stop": 98000,
        "take_profits": [
            102000
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("genkenobi/crypto-signal-checker").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 = { "signal": {
        "symbol": "BTC",
        "direction": "LONG",
        "entry": 100000,
        "stop": 98000,
        "take_profits": [102000],
    } }

# Run the Actor and wait for it to finish
run = client.actor("genkenobi/crypto-signal-checker").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 '{
  "signal": {
    "symbol": "BTC",
    "direction": "LONG",
    "entry": 100000,
    "stop": 98000,
    "take_profits": [
      102000
    ]
  }
}' |
apify call genkenobi/crypto-signal-checker --silent --output-dataset

```

## MCP server setup

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

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/biw2pgudf4CPxnOsC/builds/UEoWoYDz7dpb8E2Zr/openapi.json