# Bitcoin Pulse (`0xgollum/bitcoin-pulse`) Actor

One live signal feed for Bitcoin: price momentum, funding rates, open interest, long/short ratio and the Fear & Greed index — distilled into a pulse score and actionable trader signals.

- **URL**: https://apify.com/0xgollum/bitcoin-pulse.md
- **Developed by:** [0xGollum](https://apify.com/0xgollum) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 19 total users, 8 monthly users, 25.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Bitcoin Pulse ₿

**One live signal feed that tells you what Bitcoin is actually doing — momentum, leverage, positioning and sentiment — in a single pulse score.**

Most crypto tools hand you a wall of raw numbers. Bitcoin Pulse reads the numbers *for* you: it pulls price momentum, **funding rates**, **open interest**, the **long/short ratio** and the **Fear & Greed index**, then distills them into a **pulse score** (‑100 → +100) and a short list of **named, actionable signals**.

### What a row looks like

A fired signal, straight from the dataset:

```json
{
  "type": "signal",
  "symbol": "BTCUSDT",
  "signal": "overheated_longs",
  "direction": "bearish",
  "strength": "high",
  "message": "Funding 0.050%/8h with crowd long — long-squeeze risk."
}
```

Every run also returns a `snapshot` row per symbol (price, funding, open interest, long/short ratio, Fear & Greed, `pulse_score`, `regime`) — even when no signal fires, so you never get an empty dataset. Full field list under [Output](#output) below.

***

### What you get

**A pulse score & regime**, per symbol: `bullish` · `leaning_bullish` · `neutral` · `leaning_bearish` · `bearish`.

**Actionable signals** — only the ones that actually fire:

| Signal | Meaning |
|--------|---------|
| `momentum_up` / `momentum_down` | Price accelerating up/down on the hour |
| `overheated_longs` | Hot funding + crowd long → long-squeeze risk |
| `short_squeeze_setup` | Negative funding + crowd short → squeeze fuel |
| `capitulation` | Extreme Fear into a red day → contrarian bottom watch |
| `euphoria` | Extreme Greed into a green day → chase with caution |
| `funding_flip_positive/negative` | Funding crossed zero since last run |
| `leverage_building` / `leverage_flush` | Open interest rising/falling → positioning shift |
| `volume_spike` | Last hour trading well above its recent average |

Signals like *funding flip* and *leverage building* compare against the **previous run**, so the Actor gets sharper the more often you schedule it.

**Every run returns a result.** On a quiet market where nothing fires, you get a `status` row with the current reading instead of an empty dataset.

### Sources (all public, no API key)

Market data is aggregated across **four exchanges in parallel** — if one is
unreachable, the others fill the gap, so every row comes back complete:

- **OKX / Bybit** — price, hourly momentum & volume, funding rate, open interest, long/short account ratio
- **Coinbase / Kraken** — price & 24h stats (extra redundancy), hourly momentum
- **alternative.me** — Fear & Greed index
- **mempool.space** — network fees & mempool backlog

### Use cases

- **Traders** — a fast read on regime & leverage before entering, without ten tabs open
- **Bots & automations** — pipe clean signals into your own alerting/trading flow (Make, Zapier, n8n, custom)
- **Dashboards** — a single, structured Bitcoin health feed to render however you like

### Input (all optional)

| Field | Default | Description |
|-------|---------|-------------|
| `symbols` | `["BTCUSDT"]` | Binance symbols to analyze (add `ETHUSDT`, `SOLUSDT`, …) |
| `include_snapshots` | `true` | Emit a full-metrics snapshot row per symbol |
| `only_signals` | `false` | Output only fired signals, skip snapshots |
| `momentum_up_threshold` | `1.0` | % 1h gain to fire `momentum_up` |
| `funding_hot_threshold` | `0.0003` | Funding (/8h) flagged as overheated longs |
| `funding_cold_threshold` | `-0.0001` | Funding (/8h) flagged as squeeze setup |
| `volume_spike_threshold` | `2.0` | Last-hour volume vs average to flag a spike |
| `open_interest_move_pct` | `5.0` | % OI change vs last run to flag leverage moves |

### Output

Two row types. A **snapshot** (all metrics + score):

```json
{
  "type": "snapshot",
  "symbol": "BTCUSDT",
  "price_usd": 62882,
  "price_change_h1": 0.35,
  "price_change_h24": 0.30,
  "funding_rate": 0.0001,
  "open_interest": 103212,
  "long_short_ratio": 1.53,
  "fear_greed": 24,
  "fear_greed_class": "Extreme Fear",
  "pulse_score": -3,
  "regime": "neutral",
  "active_signals": []
}
```

…and a **signal** row for each fired condition:

```json
{
  "type": "signal",
  "symbol": "BTCUSDT",
  "signal": "overheated_longs",
  "direction": "bearish",
  "strength": "high",
  "message": "Funding 0.050%/8h with crowd long — long-squeeze risk."
}
```

### Pricing

**Pay per result:** **$0.002 per row** (snapshots + signals). A default Bitcoin-only run is a fraction of a cent. Set `only_signals: true` to pay only when something actually fires.

### Tips

- **Schedule it** every 15–60 min — the velocity signals (funding flips, leverage building) only work with run-to-run history.
- Bitcoin-first by design; add altcoins via `symbols` when you want a wider read.

***

*⚠️ Not financial advice. Crypto is high-risk and highly leveraged. This Actor surfaces market data and heuristics — it does not tell you what to trade. Always do your own research. All data from public sources.*

# Actor input Schema

## `symbols` (type: `array`):

Perpetual symbols to analyze (data is aggregated across OKX, Bybit, Coinbase and Kraken). Default is Bitcoin only. Examples: BTCUSDT, ETHUSDT, SOLUSDT.

## `include_snapshots` (type: `boolean`):

Emit one full-metrics snapshot row per symbol (price, funding, OI, L/S, Fear & Greed, pulse score, regime), in addition to any signals.

## `only_signals` (type: `boolean`):

If enabled, output only fired signal rows and skip the snapshot rows. On a quiet run where nothing fires, a single lightweight 'status' row with the current market reading is still returned (the run is never empty).

## `momentum_up_threshold` (type: `number`):

Minimum 1h price gain (%) to fire a momentum\_up signal.

## `momentum_down_threshold` (type: `number`):

Maximum 1h price move (%, negative) to fire a momentum\_down signal.

## `funding_hot_threshold` (type: `number`):

Funding rate at/above this (e.g. 0.0003 = 0.03%/8h) flags overheated longs.

## `funding_cold_threshold` (type: `number`):

Funding rate at/below this (e.g. -0.0001) flags a potential short squeeze.

## `volume_spike_threshold` (type: `number`):

Last-hour volume divided by recent average must reach this to fire volume\_spike.

## `open_interest_move_pct` (type: `number`):

Percent change in open interest vs the previous run to flag leverage building/flushing.

## `max_results` (type: `integer`):

Maximum rows returned per run. The free preview is capped at 25 — raise this once you need the full feed.

## Actor input object example

```json
{
  "symbols": [
    "BTCUSDT"
  ],
  "include_snapshots": true,
  "only_signals": false,
  "momentum_up_threshold": 1,
  "momentum_down_threshold": -1,
  "funding_hot_threshold": 0.0003,
  "funding_cold_threshold": -0.0001,
  "volume_spike_threshold": 2,
  "open_interest_move_pct": 5,
  "max_results": 25
}
```

# 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("0xgollum/bitcoin-pulse").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("0xgollum/bitcoin-pulse").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 '{}' |
apify call 0xgollum/bitcoin-pulse --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,0xgollum/bitcoin-pulse"
        }
    }
}

```

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/w4IeIbYMMlFvfgmM8/builds/u8TZb94P44MVuSuky/openapi.json