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

📈 Fetch current and historical Alternative.me Crypto Fear & Greed Index values for crypto dashboards, alerts, analysis, and trading workflows.

- **URL**: https://apify.com/automation-lab/crypto-fear-and-greed-index-scraper.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.60 / 1,000 index records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Fetch the current and historical Alternative.me Crypto Fear & Greed Index as clean Apify dataset records.

The actor is built for crypto traders, analysts, market dashboard builders, newsletter teams, quant researchers, and automation workflows that need a daily sentiment series without maintaining custom API glue.

It calls the public Alternative.me API, normalizes every record, and stores one dataset item per daily index value.

### What does Crypto Fear and Greed Index Scraper do?

Crypto Fear and Greed Index Scraper extracts the daily 0-100 crypto sentiment score from Alternative.me.

Each result includes:

- 📈 numeric sentiment value
- 🏷️ classification such as Extreme Fear, Fear, Neutral, Greed, or Extreme Greed
- 🕒 Unix timestamp and normalized ISO date
- ⏳ time until the next source update when the API provides it
- 🔗 exact source URL used for the run
- 🧾 fetch timestamp for audit trails

Use `limit: 1` for the latest daily reading or a larger limit for historical analysis.

### Who is it for?

This actor is useful for multiple crypto data workflows.

- Crypto traders who monitor sentiment extremes before entries or exits
- Analysts who need a daily sentiment feature for dashboards
- Newsletter writers who publish daily or weekly market mood summaries
- Quant teams that backtest sentiment overlays
- Portfolio managers who want a risk-on / risk-off input
- Data engineers who need a scheduled dataset instead of hand-written API jobs
- No-code users who want CSV, Excel, JSON, XML, or API access to the same data

### Why use this actor?

Alternative.me already provides a public endpoint, but production workflows still need repeatable runs, datasets, exports, scheduling, and integrations.

This actor adds those workflow features on top of the public API.

- ✅ Ready for Apify schedules
- ✅ Dataset exports in common formats
- ✅ API access from Node.js, Python, cURL, Make, Zapier, and dashboards
- ✅ Normalized field names
- ✅ Low-memory HTTP-only execution
- ✅ Pay-per-event pricing designed for small and large pulls

### Data source

The actor uses the Alternative.me Fear & Greed Index API:

`https://api.alternative.me/fng/`

The source publishes a composite crypto sentiment index.

The actor does not require login, cookies, browser rendering, or residential proxies.

### Output data table

| Field | Type | Description |
| --- | --- | --- |
| `source` | string | Source name, `alternative.me` |
| `sourceUrl` | string | API URL used for the run |
| `indexName` | string | Index name from the source response |
| `value` | number | Sentiment score from 0 to 100 |
| `valueClassification` | string | Human-readable classification |
| `classificationSlug` | string | Machine-friendly classification slug |
| `timestamp` | number | Source Unix timestamp in seconds |
| `date` | string | Normalized date in `YYYY-MM-DD` format |
| `dateUtc` | string | Full UTC ISO timestamp |
| `timeUntilUpdate` | number/null | Seconds until next update for the latest value when available |
| `timeUntilUpdateHours` | number/null | Same countdown converted to hours |
| `isLatest` | boolean | `true` for the newest record in the response |
| `fetchedAt` | string | Actor fetch timestamp |
| `raw` | object | Optional raw source record when `includeRaw` is enabled |

### How much does it cost to scrape Crypto Fear and Greed Index data?

The actor uses pay-per-event pricing.

You pay a small start fee and a per-record fee for each daily index record returned.

Because the source is a public lightweight API, runs are typically inexpensive.

Example use cases:

- Latest value: `limit: 1`
- 100-day dashboard window: `limit: 100`
- Multi-year backtest: increase `limit` up to the configured maximum

See the Apify run cost estimate before starting large jobs.

### How to use it

1. Open the actor on Apify.
2. Set **Number of daily records**.
3. Optionally choose a raw API date format.
4. Click **Start**.
5. Export the dataset or connect it to your automation.

For the latest score, use:

```json
{
  "limit": 1
}
````

For a 100-day historical window, use:

```json
{
  "limit": 100,
  "dateFormat": "world"
}
```

### Input options

#### `limit`

Number of newest daily index records to fetch.

Default: `1`

Prefill: `20`

Minimum: `1`

Maximum: `5000`

#### `dateFormat`

Optional Alternative.me `date_format` parameter.

Supported values:

- `world`
- `us`
- `cn`
- `kr`

The actor always emits normalized ISO fields, so this setting mainly affects raw source compatibility.

#### `includeRaw`

When enabled, the actor includes the original Alternative.me record under `raw`.

Use it when you want to audit the exact source payload or preserve extra source fields.

### Output example

```json
{
  "source": "alternative.me",
  "sourceUrl": "https://api.alternative.me/fng/?limit=1&format=json",
  "indexName": "Fear and Greed Index",
  "value": 17,
  "valueClassification": "Extreme Fear",
  "classificationSlug": "extreme_fear",
  "timestamp": 1782259200,
  "date": "2026-06-23",
  "dateUtc": "2026-06-23T00:00:00.000Z",
  "timeUntilUpdate": 49358,
  "timeUntilUpdateHours": 13.71,
  "isLatest": true,
  "fetchedAt": "2026-06-24T07:15:00.000Z"
}
```

### Tips for reliable workflows

- Use a schedule after the source updates each day.
- Keep `limit: 1` for daily alerting workflows.
- Use `limit: 100` or more for dashboards that need rolling charts.
- Enable `includeRaw` only when you need raw compatibility.
- Use the dataset API for automated ingestion into BI tools.

### Integrations

The actor works with standard Apify integrations.

Common workflow patterns:

- Send the latest reading to Slack or Discord every morning.
- Append daily values to Google Sheets.
- Feed a crypto dashboard in Looker Studio, Retool, or Streamlit.
- Trigger risk alerts when the value crosses a threshold.
- Use historical output as a feature in backtesting notebooks.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/crypto-fear-and-greed-index-scraper').call({
  limit: 100,
  dateFormat: 'world',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/crypto-fear-and-greed-index-scraper').call(run_input={
    'limit': 100,
    'dateFormat': 'world',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~crypto-fear-and-greed-index-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"limit":100,"dateFormat":"world"}'
```

### MCP integration

Use the Apify MCP server with Claude Code or Claude Desktop to call this actor from agent workflows.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/crypto-fear-and-greed-index-scraper`

Claude Code setup:

```bash
claude mcp add apify-crypto-fear-greed https://mcp.apify.com/?tools=automation-lab/crypto-fear-and-greed-index-scraper
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Run the Crypto Fear and Greed Index Scraper for the latest value and summarize the market mood."
- "Fetch 365 days of Crypto Fear and Greed Index data and identify the lowest sentiment periods."
- "Compare today's crypto fear reading against the last 30 days."

### Scheduling ideas

A daily schedule is the most common setup.

Recommended schedule:

- Run once per day after the Alternative.me update window.
- Use `limit: 1` for alerts.
- Use `limit: 30` or `limit: 100` for rolling dashboards.

### Monitoring ideas

You can monitor sentiment thresholds with downstream automations.

Examples:

- Alert when value is below 20.
- Alert when value is above 80.
- Create a weekly summary of classification changes.
- Flag rapid changes between consecutive daily records.

### Troubleshooting

#### Why did I get fewer records than expected?

The source API controls available history. If the requested limit exceeds available records, the actor returns what the API provides.

#### Why is `timeUntilUpdate` null on older records?

Alternative.me usually provides the countdown only on the newest record. Historical records may not include it.

#### Do I need a proxy?

No. The actor uses a public API and does not need Apify Proxy.

### Legality and terms

This actor retrieves publicly available API data from Alternative.me.

You are responsible for using the data in compliance with applicable laws, exchange rules, platform terms, and your own trading or publication policies.

The actor does not provide financial advice.

### Related scrapers

Explore related actors by Automation Lab:

- https://apify.com/automation-lab/coinbase-scraper
- https://apify.com/automation-lab/crypto-news-scraper
- https://apify.com/automation-lab/stock-market-news-scraper
- https://apify.com/automation-lab/yahoo-finance-scraper

### FAQ

#### Can I fetch the latest index only?

Yes. Use `limit: 1`.

#### Can I fetch historical records?

Yes. Increase `limit` to retrieve more recent daily records.

#### Is the data sorted newest first?

Yes. Alternative.me returns newest records first, and the actor preserves that order.

#### Can I export to CSV or Excel?

Yes. Use Apify dataset exports after the run finishes.

#### Can I use this in a trading bot?

Yes, as a data input. The actor does not execute trades and does not provide financial advice.

### Changelog

Initial version:

- Public Alternative.me API integration
- Current and historical index support
- Normalized date and classification fields
- Optional raw source payload

### Support

If a run fails or the source changes, open an issue from the Apify run page and include the run ID.

### Data freshness

The source updates daily.

For always-current workflows, schedule this actor once per day.

### Performance

This is an HTTP-only actor with 256 MB memory by default.

No browser is launched, which keeps runs fast and inexpensive.

### Version

Current actor version: `0.1`.

# Actor input Schema

## `limit` (type: `integer`):

How many newest daily Crypto Fear & Greed Index records to fetch. Use 1 for the latest value or 100+ for historical dashboards/backtests.

## `dateFormat` (type: `string`):

Optional Alternative.me date\_format parameter. Output always includes normalized ISO dates; this only affects raw source fields when included.

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

Add the original Alternative.me record under raw for debugging or field-parity checks.

## Actor input object example

```json
{
  "limit": 20,
  "dateFormat": "world",
  "includeRaw": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

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

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

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/crypto-fear-and-greed-index-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "limit": 20,
  "dateFormat": "world",
  "includeRaw": false
}' |
apify call automation-lab/crypto-fear-and-greed-index-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/crypto-fear-and-greed-index-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto Fear and Greed Index Scraper",
        "description": "📈 Fetch current and historical Alternative.me Crypto Fear & Greed Index values for crypto dashboards, alerts, analysis, and trading workflows.",
        "version": "0.1",
        "x-build-id": "S5H7cCZhDKF4FG7zu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~crypto-fear-and-greed-index-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-crypto-fear-and-greed-index-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~crypto-fear-and-greed-index-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-crypto-fear-and-greed-index-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~crypto-fear-and-greed-index-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-crypto-fear-and-greed-index-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "limit": {
                        "title": "Number of daily records",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many newest daily Crypto Fear & Greed Index records to fetch. Use 1 for the latest value or 100+ for historical dashboards/backtests.",
                        "default": 1
                    },
                    "dateFormat": {
                        "title": "Raw API date format",
                        "enum": [
                            "world",
                            "us",
                            "cn",
                            "kr"
                        ],
                        "type": "string",
                        "description": "Optional Alternative.me date_format parameter. Output always includes normalized ISO dates; this only affects raw source fields when included.",
                        "default": "world"
                    },
                    "includeRaw": {
                        "title": "Include raw API record",
                        "type": "boolean",
                        "description": "Add the original Alternative.me record under raw for debugging or field-parity checks.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```