# Tokenomics Analyzer — Inflation, Dilution & Quality Grader (`gochujang/tokenomics-analyzer`) Actor

Analyze token economic design: inflation impact score, tokenomics quality grade (A+ to F), real dilution rate, supply shock risk, utility capture, fair launch score, and ideal holding period. Covers 100+ tokens via CoinGecko. No API key required.

- **URL**: https://apify.com/gochujang/tokenomics-analyzer.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 token analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Tokenomics Analyzer do?

**Tokenomics Analyzer** evaluates the economic design quality of 50+ major crypto assets using public APIs (CoinGecko, DefiLlama) — no API key required. For each token it computes 24 analytics fields covering **crypto token distribution**, **vesting schedule analysis**, inflation risk, unlock sell pressure, VC overhang, real yield, and a composite tokenomics health score (0–100). This **tokenomics analyzer** is the fastest way to score and rank tokens by structural quality rather than price momentum.

### Why use Tokenomics Analyzer?

- **Due diligence automation** — screen any token's economic design before investing: check insider allocation, VC overhang, and emission schedules without reading 50-page whitepapers
- **Vesting cliff alerts** — surface tokens with imminent unlock events that could create near-term **vesting schedule analysis** sell pressure before the market prices it in
- **Portfolio quality scoring** — rank your holdings by `tokenomics_health_score` to identify which positions carry structural inflation risk vs. real yield
- **Research & comparison** — compare token designs across sectors (L1, DeFi, AI) to find which projects have the healthiest distribution and lowest dilution rate
- **Quantitative screening** — sort by `real_dilution_rate`, `inflation_risk_tier`, or `fair_launch_score` to build screeners that go beyond market cap and price action

### How to use Tokenomics Analyzer

1. Open the **Tokenomics Analyzer** actor on Apify Store
2. Click **Try for free** — no API key or wallet connection needed
3. (Optional) Set `tokens` to a custom list of CoinGecko IDs, or leave blank to analyze the top 50 by market cap
4. Set `sortBy` to your preferred ranking metric (e.g. `quality_grade`, `inflation_asc`, `real_dilution_asc`)
5. Click **Run** — the actor fetches and scores all tokens, then saves results to the dataset
6. Download as JSON/CSV or integrate via the Apify API for automated screeners

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `tokens` | string\[] | top 50 by market cap | CoinGecko token IDs to analyze |
| `sortBy` | string | `market_cap_desc` | Sort order for results. Options: `market_cap_desc`, `inflation_asc`, `inflation_desc`, `quality_grade`, `real_dilution_asc`, `real_dilution_desc`, `utility_score_desc`, `fair_launch_desc` |
| `limit` | integer | `50` | Maximum number of token records to return |

### Output

One record per token pushed to the dataset, plus a portfolio summary saved to the Key-Value Store under `tokenomics-analyzer-summary`.

```json
[
  {
    "token_name": "Arbitrum",
    "symbol": "ARB",
    "chain": "ethereum",
    "market_cap_usd": 1820000000,
    "circulating_supply": 3200000000,
    "max_supply": 10000000000,
    "annual_emission_rate_pct": 2.1,
    "insider_allocation_pct": 44.0,
    "tokenomics_health_score": 52,
    "tokenomics_quality_grade": "C",
    "inflation_risk_tier": "moderate",
    "real_dilution_rate": 2.1,
    "unlock_sell_pressure_score": 61,
    "vc_overhang_risk": "significant",
    "distribution_fairness_grade": "D",
    "real_yield_score": 38,
    "token_utility_strength": "moderate",
    "supply_shock_probability": "moderate",
    "ideal_holding_period": "medium_term"
  }
]
```

### Data fields

| Field | Range / Values | Description |
|---|---|---|
| `tokenomics_health_score` | 0–100 | Overall tokenomics quality composite |
| `tokenomics_quality_grade` | A+ / A / B / C / D / F | Letter grade for token economic design |
| `inflation_risk_tier` | deflationary / ultra_low / low / moderate / high / hyperinflationary | Annual emission relative to market cap |
| `real_dilution_rate` | float | Actual annual dilution rate (negative = deflationary) |
| `unlock_sell_pressure_score` | 0–100 | Team + VC unlock schedule impact on price (higher = more pressure) |
| `vc_overhang_risk` | minimal / moderate / significant / critical | VC allocation vs. float risk |
| `token_velocity` | low / moderate / high / speculative | On-chain transaction velocity proxy |
| `distribution_fairness_grade` | A / B / C / D / F | Public vs. insider allocation fairness |
| `real_yield_score` | 0–100 | Staking APY + protocol fee share + governance quality |
| `token_utility_strength` | strong / moderate / weak / speculative / none | Gas + staking + fee + governance utility |
| `supply_shock_probability` | high / moderate / low / minimal | Near-term unlock events vs. circulating supply |
| `vesting_cliff_risk` | imminent / near_term / medium_term / long_term / complete | Days to next major unlock event |
| `fair_launch_score` | 0–100 | ICO price vs. current + team allocation + public sale % |
| `ideal_holding_period` | short_term_only / medium_term / long_term_hold / indefinite_hold | Structural holding recommendation |
| `insider_allocation_pct` | float | % of total supply held by team + VCs |
| `fdv_to_mcap_ratio` | float | Fully diluted valuation ÷ market cap (>3 = heavy future dilution risk) |

### Cost estimation

| Usage | Cost |
|---|---|
| 50 tokens (default run) | $0.05 per run |
| 100 tokens | $0.10 per run |
| Daily screening of 50 tokens | ~$1.50/month |
| Weekly portfolio audit | ~$0.20/month |

**Pricing model:** $0.001 per token analyzed (Pay-Per-Event). No API key costs.

### FAQ

**Which tokens are analyzed by default?**
The actor fetches the top 50 tokens by market cap from CoinGecko by default. You can override this with any custom list of CoinGecko token IDs (e.g. `["bitcoin", "ethereum", "arbitrum", "optimism"]`).

**How is the tokenomics health score calculated?**
The `tokenomics_health_score` (0–100) is a composite of inflation rate, distribution fairness, real yield, token utility, and unlock pressure. A score above 70 indicates strong structural design; below 40 indicates high dilution or misaligned incentives.

**Can this detect rug pulls or scam tokens?**
No — this actor analyzes publicly available tokenomics data for established tokens (primarily top 50–200 by market cap). It is not designed for new or unverified token launches. For rug pull risk on new tokens, see the Memecoin Launch Detector actor.

***

### Related actors

- [Altcoin BTC-Relative Performance](https://apify.com/gochujang/altcoin-btc-performance) — Price performance vs BTC to pair with tokenomics quality scores
- [DeFi Yield APY Scanner](https://apify.com/gochujang/defi-yield-scanner) — Real yield from protocols to validate `real_yield_score` in tokenomics data
- [Crypto Correlation Matrix](https://apify.com/gochujang/crypto-correlation-matrix) — Portfolio correlation to combine with tokenomics quality for diversified basket construction

### Feedback

If this actor improves your token due diligence, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/tokenomics-analyzer#reviews)

> **Disclaimer:** Tokenomics Analyzer provides data-driven analysis of token economic design based on publicly available information. It does not constitute financial advice. Token metrics can change rapidly due to governance decisions, market conditions, or protocol upgrades. Always verify critical data before making investment decisions.

***

**Keywords:** tokenomics, token economics, inflation rate, dilution, supply schedule, CoinGecko, token grading, fair launch, utility capture, vesting, crypto research, token analysis

# Actor input Schema

## `tokenIds` (type: `array`):

Specific CoinGecko token IDs to analyze (e.g. \['bitcoin','ethereum','solana']). Leave empty for top-100 by market cap.

## `minMarketCapUsd` (type: `integer`):

Only include tokens with market cap above this threshold.

## `gradeFilter` (type: `array`):

Only return tokens with these tokenomics quality grades (A+, A, B, C, D, F). Leave empty for all grades.

## `supplyShockFilter` (type: `string`):

Minimum supply shock risk level to include.

## `sortBy` (type: `string`):

How to sort the results.

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

Maximum number of token records to return.

## Actor input object example

```json
{
  "tokenIds": [],
  "minMarketCapUsd": 100000000,
  "gradeFilter": [],
  "supplyShockFilter": "all",
  "sortBy": "market_cap_desc",
  "limit": 50
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/tokenomics-analyzer").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("gochujang/tokenomics-analyzer").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 gochujang/tokenomics-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/tokenomics-analyzer"
        }
    }
}
```

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/6wffvN8RV4XRWu7VX/builds/wW2wqaigEVFRIhvMx/openapi.json