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:

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

Thirty-day dashboard refresh:

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

One-year backtest input:

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

Output example

A current run produces rows shaped like this:

{
  "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:

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

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

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:

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:

{
  "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 can add price and market context to sentiment observations.
• 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.