# Crypto Fear and Greed Index Scraper (`automation-lab/crypto-fear-greed-index`) Actor

Retrieve current and historical Alternative.me Crypto Fear and Greed Index values, classifications, timestamps, and update timing for dashboards and backtests.

- **URL**: https://apify.com/automation-lab/crypto-fear-greed-index.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.36 / 1,000 item extracteds

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

## Crypto Fear and Greed Index Scraper

Retrieve the current and historical **crypto fear and greed index** from Alternative.me as normalized dataset rows. Each observation includes the 0–100 value, classification, Unix timestamp, UTC date, source URL, and update timing when the source provides it.

Use the Actor to refresh trading dashboards, build sentiment backtests, feed spreadsheets, or run scheduled market alerts without maintaining an API client.

### What this Actor does

The Actor calls Alternative.me's public Fear and Greed Index JSON endpoint and turns its response into integration-ready records.

It can:

- fetch only today's newest observation;
- retrieve up to 5,000 daily historical observations in one run;
- normalize source timestamps into Unix, date-only, and ISO 8601 fields;
- expose both human-readable and machine-friendly classifications;
- report the source's countdown to the next update when available;
- optionally retain the original source record under `raw`;
- retry bounded transient network, rate-limit, and server failures.

No API key, login, browser, proxy, or cryptocurrency exchange account is required.

### Who is it for

This Actor is useful for:

- **crypto traders** adding a sentiment regime to a market dashboard;
- **quant researchers** joining daily sentiment with price candles for backtests;
- **analysts** exporting current and historical readings to CSV, Excel, or BI tools;
- **automation teams** scheduling a daily refresh and forwarding new rows;
- **developers** who want stable normalized fields instead of source-specific JSON;
- **content teams** tracking changes in broad crypto market sentiment.

The index is a contextual sentiment signal, not trading advice or a guarantee of market direction.

### Why use this Crypto Fear and Greed Index scraper

A direct API call is simple, but production workflows still need input validation, retry behavior, timestamp normalization, dataset storage, scheduling, webhooks, API access, and predictable output.

This Actor packages those pieces into one reusable Apify run. It returns one row per useful observation and never charges an item event for rejected or missing data.

Compared with broad crypto-market Actors, this product stays focused on Alternative.me's index. It does not mix prices, market caps, social posts, or proprietary signals into the output.

### Extracted data

| Field | Type | Meaning |
| --- | --- | --- |
| `source` | string | Always `alternative.me` |
| `sourceUrl` | string | Exact public API URL requested |
| `indexName` | string | Source-provided index name |
| `value` | number | Sentiment score from 0 to 100 |
| `valueClassification` | string | Source classification such as `Fear` or `Greed` |
| `classificationSlug` | string | Machine-friendly form such as `extreme_fear` |
| `timestamp` | number | Observation time in Unix seconds |
| `date` | string | UTC date in `YYYY-MM-DD` format |
| `dateUtc` | string | ISO 8601 observation timestamp |
| `timeUntilUpdateSeconds` | number or null | Source countdown to the next update |
| `timeUntilUpdateHours` | number or null | Countdown converted to hours |
| `isLatest` | boolean | Whether the row is newest in this response |
| `fetchedAt` | string | ISO time when this run fetched the response |
| `raw` | object, optional | Original source row when requested |

Historical rows normally have no update countdown, so the timing fields can be `null`.

### Getting started

1. Open the Actor input page in Apify Console.
2. Set **Maximum observations** to `1` for the latest value or a larger number for history.
3. Leave **Include raw source record** off unless you need source-field parity.
4. Click **Start**.
5. Open the **Dataset** tab to inspect, download, or integrate the rows.
6. Save the configuration as a Task if you want a repeatable schedule or webhook.

The default prefill requests 20 daily observations, which is useful for validating a rolling dashboard.

### Input parameters

#### `maxItems`

Maximum number of newest daily observations to return.

- Type: integer
- Default: `1`
- Prefill: `20`
- Minimum: `1`
- Maximum: `5000`

The source returns newest-first data. `isLatest` is true only for the first row returned by the run.

#### `includeRaw`

When true, adds the original Alternative.me object under `raw`.

- Type: boolean
- Default: `false`

Normalized fields remain present either way. Keep this disabled when you want the smallest datasets and a stable integration contract.

### Input examples

Latest observation:

```json
{
  "maxItems": 1,
  "includeRaw": false
}
```

Thirty-day dashboard refresh:

```json
{
  "maxItems": 30,
  "includeRaw": true
}
```

One-year backtest input:

```json
{
  "maxItems": 365,
  "includeRaw": false
}
```

### Output example

A current run produces rows shaped like this:

```json
{
  "source": "alternative.me",
  "sourceUrl": "https://api.alternative.me/fng/?limit=30&format=json",
  "indexName": "Fear and Greed Index",
  "value": 62,
  "valueClassification": "Greed",
  "classificationSlug": "greed",
  "timestamp": 1788134400,
  "date": "2026-08-31",
  "dateUtc": "2026-08-31T00:00:00.000Z",
  "timeUntilUpdateSeconds": 62772,
  "timeUntilUpdateHours": 17.44,
  "isLatest": true,
  "fetchedAt": "2026-08-31T06:45:00.000Z"
}
```

Values and classifications change as Alternative.me updates the index. The output example demonstrates the schema, not a forecast.

### How much does it cost to extract Crypto Fear and Greed Index observations?

Pricing uses two declared events:

- a one-time **Run started** event of **$0.001 per run**;
- an **Item extracted** event for each useful observation, with a BRONZE price of **$0.0006 per item** and lower prices on higher Apify tiers.

At BRONZE, calculate a run as the $0.001 start event plus the number of useful observations multiplied by the $0.0006 item event:

| Useful observations | Charge calculation |
| ---: | --- |
| 1 | start + 1 item event |
| 30 | start + 30 item events |
| 365 | start + 365 item events |
| 1,000 | start + 1,000 item events |

These examples explain the event calculation without promising a fixed total across Apify pricing tiers. Your Apify plan and platform usage rules still apply. Failed requests and invalid source records do not emit item events.

### Dashboard workflow

Create a Task with `maxItems: 30` and schedule it daily. Downstream code can sort or deduplicate by `timestamp`, then replace a rolling dashboard table.

Useful dashboard columns are:

- `date`;
- `value`;
- `valueClassification`;
- `timeUntilUpdateHours` on the current row;
- `fetchedAt` for refresh observability.

For append-only storage, use `timestamp` as the stable observation key rather than `fetchedAt`.

### Backtesting workflow

Run with `maxItems: 365`, `1000`, or another bounded history depth. Export JSON or CSV and join `date` against daily market candles.

Common research questions include:

- performance after an `extreme_fear` observation;
- drawdown behavior across sentiment regimes;
- how long classifications persist;
- whether a rule behaves differently in fear and greed periods.

Avoid look-ahead bias: align each index timestamp with data that was genuinely available at the decision time.

### Monitoring and alerts

A scheduled Task can retrieve `maxItems: 1`. Compare the returned `timestamp`, `value`, or `classificationSlug` with your last processed record before sending an alert.

Examples:

- notify when classification changes;
- alert when value enters an extreme regime;
- refresh a daily spreadsheet row;
- trigger a webhook after each successful Task run.

The Actor itself exports observations. It does not send trading orders or guarantee real-time notifications.

### Spreadsheet and data-pipeline exports

Apify datasets can be downloaded as JSON, CSV, Excel, XML, or RSS. You can also read them through the dataset API.

For repeat pipelines:

1. run a saved Task;
2. receive the run webhook;
3. fetch default dataset items;
4. deduplicate using `timestamp`;
5. store the rows in your warehouse or spreadsheet.

The normalized date and classification fields avoid source-specific transformation in each destination.

### API usage with cURL

Start the Actor and wait for completion:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~crypto-fear-greed-index/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems": 30, "includeRaw": false}'
```

Keep your Apify token in an environment variable or secret manager. Do not commit it to source control.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/crypto-fear-greed-index').call({
  maxItems: 365,
  includeRaw: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

Use `timestamp` when merging rows from repeated runs.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/crypto-fear-greed-index').call(
    run_input={'maxItems': 30, 'includeRaw': True}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

Install the client with `pip install apify-client`.

### Use with Apify MCP

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/crypto-fear-greed-index"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this equivalent MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/crypto-fear-greed-index"
    }
  }
}
```

Example prompts:

- “Fetch the latest Crypto Fear and Greed Index and summarize its classification.”
- “Create a 365-day Alternative.me sentiment dataset for a backtest.”
- “Retrieve 30 observations and identify classification changes.”

### Reliability and retry behavior

The Actor performs one direct request to the public Alternative.me API. It retries only transient conditions:

- network failures and timeouts;
- HTTP 429 rate limits;
- temporary HTTP 5xx server errors.

Retries are limited to three attempts with exponential backoff and jitter. Stable 4xx responses, malformed JSON, metadata errors, and invalid observations fail the run. They are not silently converted into an empty successful dataset.

No residential proxy or browser fallback is enabled, so runs do not incur hidden proxy/browser routes.

### Limits and freshness

- Alternative.me controls index methodology, classification, history, and update timing.
- The Actor can request at most 5,000 observations per run.
- Results are newest first.
- `timeUntilUpdateSeconds` is usually available only on the newest observation.
- A scheduled run is a snapshot; it does not keep a process open between source updates.
- Source maintenance or rate limiting can temporarily fail a run after bounded retries.
- Historical source corrections can change values returned by a later run.

For strict audit requirements, retain the dataset and `fetchedAt` from each scheduled run.

### Data interpretation

The 0–100 index and its classifications are produced by Alternative.me. This Actor does not independently calculate, verify, endorse, or modify the sentiment methodology.

Treat the index as one contextual input. Validate any strategy across suitable market periods and risk controls. Neither the data nor this Actor is financial advice.

### Responsible use and legality

The Actor accesses a public no-auth JSON endpoint. Use the output consistently with Alternative.me's terms and attribution requirements, Apify's policies, and laws applicable to your project.

Do not present the data as your proprietary index. Do not use it to make deceptive performance claims. If you redistribute a derived product, review the source's current attribution and commercial-use terms.

### Troubleshooting

#### Why did the run fail with an input error?

`maxItems` must be a whole number from 1 through 5,000, and `includeRaw` must be boolean. Correct the input and rerun.

#### Why are update timing fields null?

Alternative.me generally supplies `time_until_update` only for the newest row. Historical rows therefore have null normalized timing fields.

#### Why did the run fail instead of returning zero rows?

An invalid response is not a valid empty result. The Actor fails after bounded retries so your dashboard or alert can distinguish upstream failure from “no observations.”

#### Why do repeated runs contain the same dates?

Each run creates a new dataset snapshot of the requested newest history. Deduplicate across runs by `timestamp` when appending into external storage.

#### Should I enable a proxy?

No proxy input is necessary or supported. The selected official API route works directly and avoids additional proxy cost.

### FAQ

#### Does it need an Alternative.me API key?

No. The supported source endpoint is public and unauthenticated.

#### Can it fetch the full available history?

It can return up to 5,000 newest observations, which covers the currently relevant daily history range. The source decides how many records exist and are returned.

#### Is the latest value real time?

It is the newest value exposed by Alternative.me when the run executes. Check `fetchedAt` and the update countdown; do not interpret it as exchange-tick data.

#### Can I filter by date inside the Actor?

The input intentionally stays bounded and predictable by newest-record count. Fetch a suitable history depth and filter the normalized `date` or `timestamp` downstream.

#### Does it place trades or send alerts?

No. Use schedules, webhooks, integrations, or your own automation to act on exported observations.

#### Do raw fields cost extra?

No. `raw` is included in the same observation and does not emit a separate billing event.

### Related Automation Lab Actors

- [CoinGecko Crypto Market Data](https://apify.com/automation-lab/coingecko-crypto-market-data) can add price and market context to sentiment observations.
- [CoinGlass Liquidation Heatmap Scraper](https://apify.com/automation-lab/coinglass-liquidation-heatmap-scraper) supports separate liquidation-market research.

These are separate products with different sources and pricing. Join datasets only when the additional signals match your workflow.

### Support

If a run fails, include the run ID, sanitized input, expected history depth, and the relevant concise log message in your issue. Do not share API tokens or other secrets.

For reproducible investigations, first retry the exact input once after any temporary source incident, then compare the run's status and dataset count.

# Actor input Schema

## `maxItems` (type: `integer`):

Number of newest daily observations to return. Use 1 for the current index, 30 for a monthly dashboard, or 365+ for backtesting.

## `includeRaw` (type: `boolean`):

Include the original Alternative.me fields under raw in addition to the normalized output fields.

## Actor input object example

```json
{
  "maxItems": 20,
  "includeRaw": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all Crypto Fear and Greed Index observations.

# 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 = {
    "maxItems": 20,
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/crypto-fear-greed-index").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 = {
    "maxItems": 20,
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/crypto-fear-greed-index").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 '{
  "maxItems": 20,
  "includeRaw": false
}' |
apify call automation-lab/crypto-fear-greed-index --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/crypto-fear-greed-index"
        }
    }
}

```

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/HAK17ny4PhbeBCWrZ/builds/V6H20KidVN6oCdYjV/openapi.json