Plugin

Crypto Fear & Greed Index

alternative.me's daily crypto sentiment number, 0 (extreme fear) to 100 (extreme greed), with its label as feeds.

Data sourceNetwork: api.alternative.meDesktop onlyv1.0.0

Get early access Plugin API documentation

About

The Crypto Fear & Greed Index by alternative.me condenses volatility, momentum and volume, social media, dominance and search trends around Bitcoin into one number a day. Some traders read extreme fear as a time to look for longs and extreme greed as a time to be careful.

Before a run, the plugin downloads the whole history (daily since February 2018) and writes two feeds: crypto_fear_greed with the number and crypto_fear_greed_label with the class alternative.me gives it: Extreme Fear, Fear, Neutral, Greed or Extreme Greed.

alternative.me asks that wherever the data is shown, the source is named right next to it. The attribution line is in each feed's _meta block; use it if you publish a chart or a report with these values.

Configuration

Field	Type	Default	Description
`cache_days`Refetch after (days)	number	`1`	Days before the plugin downloads the index again. Within that time a run reads the cached feeds and needs no network.

Use it in a strategy

pythonbars = ctx.bars(1)
if bars:
    fear = ctx.data("crypto_fear_greed", bars[-1].ts)
    if fear is not None and fear < 20:
        ctx.signal("LONG")
    elif fear is not None and fear > 80:
        ctx.signal("EXIT")

The feeds are refreshed before a run whose strategy reads ctx.data, or when "Fetch external data (news and plugin feeds)" is ticked. A run on the server never fetches.

What it provides

`crypto_fear_greed`Feed	The index, a whole number from 0 to 100, under the day after the day it describes.
`crypto_fear_greed_label`Feed	The class of the same value as text: Extreme Fear, Fear, Neutral, Greed or Extreme Greed.

Data source and terms

Publisher	alternative.me, Crypto Fear & Greed Index
Terms	Read the terms
API key	None needed
Attribution	Source: Crypto Fear & Greed Index by alternative.me
Rate limit	One request per refresh for the whole history. alternative.me asks for no key and names no limit at this volume.

Hosts it may reach: api.alternative.me

When values are known

alternative.me dates each value with the UTC day it describes and publishes it around the start of that day. The exact time is not documented, so each value is stored under the next UTC day and carried forward for at most 7 days over days the vendor skipped. A bar on Tuesday reads Monday's value.

Limits

One value a day: an intraday strategy sees yesterday's number all day.
The method behind the index is alternative.me's and may change; the history is what they serve today, not necessarily what was shown on each day.
Starts in February 2018. alternative.me's rules: name the source right next to the data wherever you show it, and do not build a service that could be confused with theirs. The data stays on your machine.

Preview

json{
  "2024-03-02": 72,
  "2024-03-03": 76,
  "2024-03-04": 80,
  "2024-03-05": 55,
  "_meta": {
    "attribution": "Source: Crypto Fear & Greed Index by alternative.me",
    "delay_rule": "next_day",
    "source": "Made-up sample, not vendor data",
    "terms": "alternative.me/crypto/fear-and-greed-index/"
  }
}

A made-up sample that shows the shape of the output. Not vendor data and not a result.

The code

main.py, the file the app installs.

python"""Crypto Fear & Greed Index: alternative.me's daily sentiment number as a feed.

Before a run it downloads the whole history of the index (daily since February
2018) and writes two feeds a strategy reads:

    crypto_fear_greed         the index, 0 (extreme fear) to 100 (extreme greed)
    crypto_fear_greed_label   its class: Extreme Fear, Fear, Neutral, Greed,
                              Extreme Greed

    def on_market(self, ctx):
        bars = ctx.bars(1)
        if not bars:
            return
        fear = ctx.data("crypto_fear_greed", bars[-1].ts)
        if fear is not None and fear < 20:
            ctx.signal("LONG")

alternative.me dates each value with the UTC day it describes and publishes it
around the start of that day, computed from the day before. The exact minute
is not documented, so each value is stored under the next UTC day: a bar on
Tuesday reads Monday's value, never Tuesday's.

alternative.me asks that the source is named next to the data wherever it is
shown; the feed's `_meta.attribution` carries that line.
"""

from datetime import datetime, timezone

from orionquant_engine.plugins.kit import feeds, net

HOSTS = ("api.alternative.me",)
API = "https://api.alternative.me/fng/"
FEED = "crypto_fear_greed"
LABEL_FEED = "crypto_fear_greed_label"
DELAY_RULE = "next_day"

#: A day the vendor skipped is carried at most this long.
MAX_GAP_DAYS = 7

# The terms link is listed in docs.json, so the template check knows it is never fetched.
# The page's rules ask that the source is named next to the data: ATTRIBUTION below.
TERMS = "https://alternative.me/crypto/fear-and-greed-index/"
ATTRIBUTION = "Source: Crypto Fear & Greed Index by alternative.me"

LABELS = ("Extreme Fear", "Fear", "Neutral", "Greed", "Extreme Greed")

_API = {"api": None}


def _log(message):
    if _API["api"] is not None:
        _API["api"].log(message)


def _config(key, default):
    api = _API["api"]
    return api.get_config(key, default) if api is not None else default


def parse(payload):
    """The API's JSON to ({day: value}, {day: label}), keyed by the UTC day each
    value describes. Rows with a value outside 0 to 100 or no time are skipped.
    Raises ValueError when the answer reports an error or has no data list."""
    if not isinstance(payload, dict):
        raise ValueError("the answer is not a JSON object")
    error = (payload.get("metadata") or {}).get("error")
    if error:
        raise ValueError("alternative.me reported: {}".format(error))
    rows = payload.get("data")
    if not isinstance(rows, list):
        raise ValueError("the answer has no data list")
    values, labels = {}, {}
    for row in rows:
        if not isinstance(row, dict):
            continue
        try:
            value = int(str(row.get("value", "")).strip())
            stamp = int(str(row.get("timestamp", "")).strip())
        except ValueError:
            continue
        if not 0 <= value <= 100:
            continue
        day = datetime.fromtimestamp(stamp, tz=timezone.utc).date().isoformat()
        values[day] = value
        label = str(row.get("value_classification") or "").strip()
        if label in LABELS:
            labels[day] = label
    return values, labels


def _write(name, observed, what):
    known = feeds.shift(observed, DELAY_RULE)
    feeds.write_feed(
        name,
        feeds.fill_forward(known, until=feeds.today(), max_gap_days=MAX_GAP_DAYS),
        meta={
            "source": "alternative.me, Crypto Fear & Greed Index ({})".format(what),
            "terms": TERMS,
            "attribution": ATTRIBUTION,
            "delay_rule": DELAY_RULE,
        },
    )


def data_fetch(context):
    """Lifecycle hook: refresh both feeds before the backtest runs."""
    max_age = float(_config("cache_days", 1)) * 86400
    if feeds.fresh(FEED, max_age) and feeds.fresh(LABEL_FEED, max_age):
        return
    try:
        payload = net.get_json(API, hosts=HOSTS, params={"limit": 0})
        values, labels = parse(payload)
    except (net.NetError, ValueError) as exc:
        _log("fetch failed, the cached feeds stay: {}".format(exc))
        return
    if not values:
        _log("alternative.me returned no values, the cached feeds stay")
        return
    _write(FEED, values, "value, 0 to 100")
    if labels:
        _write(LABEL_FEED, labels, "classification")
    _log("cached {} daily Fear & Greed values".format(len(values)))


def register(api):
    _API["api"] = api
    api.register_data_fetch(data_fetch)