# Crypto Token Analysis

> Deep-dive framework for analyzing crypto tokens — market data, liquidity health, tokenomics, unlock schedules, and risk assessment. Combines on-chain data, API queries, and multi-source validation to generate actionable investment verdicts.

- Skill: `aibot88/crypto-token-analysis` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add aibot88/crypto-token-analysis`
- Raw SKILL.md: https://api.skillmd.com/api/skills/aibot88/crypto-token-analysis/raw
- Safety review: pending (external: skill-scanner FAIL, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: aibot88 (https://skillmd.com/u/aibot88)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/aibot88/crypto-token-analysis

---


# Crypto Token Deep Analysis Framework

Systematic approach for analyzing crypto tokens with focus on **profit opportunities** and **risk avoidance**. Used when user requests token analysis, investment research, or airdrop evaluation.

## When to Use

- User asks to analyze a specific token (e.g., "$HPL analysis")
- Requests for "deep dive", "fundamental analysis", or "is X token good?"
- **Airdrop opportunity evaluation** (token OR project-level)
- Risk assessment before investment
- Comparing tokens in an ecosystem
- **Analyzing crypto projects/protocols for airdrop potential** (AI agents, DeFi protocols, infrastructure)
- **Evaluating X/Twitter announcements** for alpha/farming opportunities
- **DePIN project analysis** (Decentralized Physical Infrastructure Networks — Helium, IoTeX, Peaq, Render, etc.)
- **Stock market dividend analysis** (IDX/Indonesian stocks) — see `references/idx-dividend-analysis.md` for workflow when APIs fail
- **NFT collection analysis** (OpenSea, Blur, etc.) — floor price, volume, holder distribution, project status

## Analysis Types

### Type A: Token Analysis (existing token with market data)
Use when: Token already listed on CoinGecko/CMC, has trading volume, circulating supply.

### Type B: Project/Protocol Analysis (pre-token or early-stage)
Use when: Analyzing for **airdrop potential**, product is live but no token yet, or token just launched with minimal data.

**Key difference:** Type B focuses on **product reality**, **user onboarding**, **VC backing**, and **airdrop signals** rather than liquidity metrics.

### Type C: DePIN Project Analysis (hardware-based infrastructure)
Use when: Analyzing **Decentralized Physical Infrastructure Networks** — projects requiring hardware (IoT devices, sensors, nodes, GPUs, wireless hotspots).

**Key difference:** Type C evaluates **hardware requirements**, **operator economics**, **network effects**, and **adoption barriers** unique to physical infrastructure.

### Type D: NFT Collection Analysis (floor price, volume, holders)
Use when: Analyzing **NFT collections** on OpenSea, Blur, or other marketplaces — evaluating floor price trends, trading volume, holder distribution, and project status.

**Key difference:** Type D focuses on **floor price trends**, **volume/holder ratio**, **chart patterns** (pump & dump, death spiral), and **project abandonment signals** rather than tokenomics.

---

## Core Analysis Framework (Type A: Token Analysis)

### 1. Market Data (CoinGecko API)

**Primary endpoint:**
```bash
curl -s "https://api.coingecko.com/api/v3/coins/{token_id}"
```

**Key metrics to extract:**
- Market cap & FDV (Fully Diluted Valuation)
- 24h volume
- Circulating vs total supply
- Price performance (24h, 7d, 30d)
- ATH/ATL with dates
- Contract addresses

**Critical calculation:**
```python
vol_mcap_ratio = (volume_24h / market_cap) * 100

# Benchmarks:
# Healthy: >10%
# Acceptable: 3-10%
# Weak: 1-3%
# Dead: <1%
```

### 2. Liquidity Health Assessment

**Volume/MCap ratio is THE critical metric for exit risk.**

If ratio < 1%, token is **illiquid** regardless of other fundamentals.

**Slippage estimation (rough):**
- <0.1% ratio: Expect 10-30% slippage on $5K trade
- 0.1-1%: Expect 3-10% slippage on $5K trade
- 1-5%: Expect 1-3% slippage on $5K trade
- >5%: Liquid, <1% slippage

### 3. Tokenomics & Unlock Risk

**Supply breakdown:**
```python
circulating_pct = (circulating_supply / total_supply) * 100
locked_pct = 100 - circulating_pct

# Risk levels:
# <20% locked: Low risk
# 20-50% locked: Medium risk
# 50-70% locked: High risk
# >70% locked: Extreme risk (avoid)
```

**Unlock schedule:**
- Check project docs, GitHub, or token vesting contracts
- If not disclosed = RED FLAG
- Calculate potential sell pressure per unlock event

### 4. Protocol Fundamentals (for DeFi tokens)

**For lending/DEX/yield protocols:**

```python
# Revenue efficiency
revenue_tvl_ratio = (annual_revenue / tvl) * 100

# Benchmarks (lending protocols):
# Excellent: >2%
# Good: 1-2%
# Acceptable: 0.5-1%
# Poor: <0.5%

# Utilization rate
utilization = (total_borrowed / total_supplied) * 100

# Healthy range: 40-80%
# Too low (<30%): Dead capital
# Too high (>90%): Liquidity risk
```

**TVL quality check:**
- Look for "dead capital" (high TVL, low utilization)
- Check if TVL is real or wash farming
- Compare TVL to actual user count

### 5. Ecosystem & Narrative

**Context matters:**
- Is the base chain/ecosystem growing or dying?
- Compare token performance to ecosystem native token
- Check if token is listed on major trackers (CMC, CoinGecko)

**Example comparison:**
```python
# If analyzing token on Hyperliquid:
hype_vol_mcap = 1.2%  # Native token
target_vol_mcap = 0.02%  # Your token

relative_health = target_vol_mcap / hype_vol_mcap
# If <0.1 (10x worse), token is dying relative to ecosystem
```

### 6. Sentiment & Catalyst Check

**Use delegation for:**
- Recent X/Twitter mentions (sentiment, KOL coverage)
- Upcoming events (CEX listings, partnerships, protocol upgrades)
- Community activity (Discord, Telegram, Reddit)

**Red flags:**
- No social media presence
- Last announcement >1 month ago
- Community size << TVL (fake TVL indicator)

---

## Type B: Project/Protocol Airdrop Analysis Framework

**Use when:** Analyzing projects for airdrop potential (no token yet, or token just launched with minimal market data).

### 1. Context Extraction (from X/Twitter or announcement)

**What to extract:**
- Tweet content (product update? funding? campaign? teaser?)
- Account type (official project? founder? influencer?)
- Engagement metrics (likes, RTs, replies)
- Media attached (video, images, links)

**Tools:**
```bash
# Get tweet data
curl -s "https://api.fxtwitter.com/{handle}/status/{tweet_id}" | jq -r '.tweet | {text, author, likes, retweets, replies, media}'

# Get account info
curl -s "https://api.fxtwitter.com/{handle}" | jq -r '.user | {name, description, followers, website}'
```

### 2. Project Identification

**Core questions:**
- What problem does it solve?
- Category: AI / Infra / DeFi / Identity / L2 / Gaming / etc.
- Unique edge vs competitors?
- Target users (devs? traders? consumers?)

**Research sources:**
- Project bio on X
- Website (if accessible)
- GitHub org/repos
- Documentation

### 3. Product Reality Check

**Critical validation:**
```bash
# Check GitHub
curl -s "https://api.github.com/orgs/{project}/repos" | jq -r '.[] | {name, description, stars, updated_at}'

# Check specific repo
curl -s "https://api.github.com/repos/{org}/{repo}" | jq -r '{stars, forks, created_at, updated_at, language}'

# Recent commits (activity check)
curl -s "https://api.github.com/repos/{org}/{repo}/commits?per_page=5" | jq -r '.[] | {date: .commit.author.date, message: .commit.message}'

# Check npm package (if CLI tool)
curl -s "https://registry.npmjs.org/{package}" | jq -r '{name, version, description, "dist-tags": ."dist-tags"}'
```

**Maturity indicators:**
- ✅ Live product (not just whitepaper)
- ✅ Active GitHub (commits in last 30 days)
- ✅ Documentation exists
- ✅ Testnet or mainnet deployed
- ❌ Vaporware (no code, only marketing)

### 4. Ecosystem & Backing

**VC/Funding signals:**
- Check project bio for "Backed by X"
- Search Crunchbase, Twitter for funding announcements
- Look for partner logos on website

**Ecosystem positioning:**
- Which chain(s)? (Ethereum, Solana, Cosmos, etc.)
- Part of larger narrative? (AI agents, DeFi 2.0, RWA, etc.)
- Integrations with major protocols?

**Legitimacy check:**
```bash
# Search for funding news
curl -s "https://api.duckduckgo.com/?q={project}+funding+backed&format=json" | jq -r '.AbstractText'
```

### 5. Airdrop Signal Scoring (0-10)

**Positive signals (+):**
- ✅ No token yet (or just launched)
- ✅ User onboarding flow (login, wallet connect, testnet)
- ✅ Referral system exists
- ✅ Keywords: "early", "points", "rewards", "campaign", "waitlist"
- ✅ Active community growth
- ✅ Similar to past successful airdrops (Rabby, Zapper, etc.)
- ✅ VC backing (incentive to distribute tokens)
- ✅ Freemium model (free tier + premium = points system likely)

**Negative signals (-):**
- ❌ Token already exists with full circulation
- ❌ No user onboarding (just marketing site)
- ❌ Paid-only product (no free tier)
- ❌ Explicit "no token" statement
- ❌ Revenue model is pure SaaS (subscription-only)

**Scoring formula:**
```python
score = 5  # baseline

# Product stage
if no_token_yet: score += 2
if user_onboarding: score += 1
if referral_system: score += 1

# Signals
if "points" in announcement: score += 1
if "early" in announcement: score += 0.5
if freemium_model: score += 1

# Backing
if vc_backed: score += 1
if major_vc: score += 0.5  # Circle, a16z, Paradigm, etc.

# Red flags
if paid_only: score -= 2
if explicit_no_token: score -= 5

return min(10, max(0, score))
```

**Probability estimate:**
- Score 8-10: 80-90% airdrop likely
- Score 6-7.5: 60-75% likely
- Score 4-5.5: 40-55% (speculative)
- Score <4: <40% (unlikely)

### 6. User Action Requirements

**What can users do NOW?**
- Install/signup (email, wallet, social auth)
- Complete onboarding (KYC, testnet tasks)
- Make transactions (swaps, deposits, trades)
- Referrals (invite friends)
- Social tasks (follow, retweet, Discord)

**Effort assessment:**
- LOW: Just signup/follow
- MEDIUM: Testnet transactions, small deposits
- HIGH: Mainnet activity with real funds

### 7. Momentum Analysis

**Engagement check:**
- Tweet engagement (likes/followers ratio)
- Follower growth rate
- GitHub stars growth
- Community size (Discord, Telegram)

**Stage detection:**
- Pre-early: <1K followers, no product
- Early: 1K-50K followers, MVP live
- Mid: 50K-200K followers, product mature
- Late: >200K followers, token likely soon

### 8. Red Flag Detection

**Scam/farming trap signals:**
- ❌ Hype without product
- ❌ Anonymous team
- ❌ Unrealistic promises ("10000x guaranteed")
- ❌ Requires upfront payment for "airdrop"
- ❌ Asks for private keys/seed phrases
- ❌ Fake partnerships (check official partner accounts)
- ❌ Copied code (check GitHub for forks of scam projects)

### 9. Hidden Alpha (Strategic Insights)

**Non-obvious opportunities:**
- Infrastructure play (if AI agents go mainstream, this becomes critical)
- First-mover in new category
- Potential acquisition target
- Ecosystem positioning (official tool for major protocol)
- Developer-first = sticky users (high retention)
- Cross-protocol exposure (using Project A might qualify for Project B airdrop)

**Comparison to past successes:**
- Rabby Wallet: Product-first, airdrop later → successful
- Zapper: Freemium, eventual token → successful
- LayerZero: Testnet farming → successful (but controversial)
- Arbitrum: Mainnet usage → successful

### 10. Final Verdict

**Verdict options:**
- **FARM**: High confidence, clear action path, good ROI potential
- **WATCH**: Promising but wait for explicit announcement
- **SKIP**: Low probability or too much effort for expected return
- **AVOID**: Red flags detected, likely scam/waste of time

**Output format:**
```markdown
## VERDICT: [FARM / WATCH / SKIP / AVOID]

**Score:** X/10
**Airdrop Probability:** X%
**Stage:** [Pre-early / Early / Mid / Late]

**Reasoning:**
[2-3 sentences with key data points]

**If FARM, action steps:**
1. [Specific action with command/link]
2. [Next action]
3. [Monitoring trigger]

**If WATCH, entry conditions:**
- ✅ [Condition 1]
- ✅ [Condition 2]

**Time commitment:** [LOW / MEDIUM / HIGH]
**Expected ROI (if airdrop):** $X-Y
**Risk:** [Financial / Time / Opportunity cost]
```

### 11. Strategy & Action Plan

**For FARM verdict:**
```markdown
**Immediate actions (next 24h):**
1. [Setup step with exact command]
2. [Onboarding step]
3. [First transaction/activity]

**Ongoing (weekly/monthly):**
- [Maintenance activity]
- [Monitoring what to watch]

**Exit triggers:**
- ❌ [Condition that invalidates thesis]
- ✅ [Condition to farm harder]

**Time commitment:** X hours/month
**Capital required:** $X-Y
**Risk level:** [LOW / MEDIUM / HIGH]
```

---

## Type C: DePIN Project Analysis Framework

**Use when:** Analyzing Decentralized Physical Infrastructure Networks (Helium, Peaq, IoTeX, Render, Hivemapper, etc.)

### 1. Infrastructure Type Classification

**Categories:**
- **Wireless:** Helium (5G/LoRaWAN), XNET (WiFi)
- **Compute:** Render (GPU), Akash (cloud compute), Gensyn (ML training)
- **Storage:** Filecoin, Arweave, Storj
- **Sensors/IoT:** Peaq (machine economy), IoTeX (smart devices)
- **Mapping:** Hivemapper (dashcam mapping), DIMO (vehicle data)
- **Energy:** Powerledger (grid), Arkreen (solar)

### 2. Hardware Requirements Assessment

**Critical questions:**
- What hardware is needed? (hotspot, GPU, sensor, vehicle, etc.)
- Upfront cost? ($100-$500 = accessible, $1K-$5K = medium, >$5K = high barrier)
- Technical complexity? (plug-and-play vs requires networking knowledge)
- Ongoing costs? (electricity, bandwidth, maintenance)

**Barrier entry scoring:**
```python
barrier_score = 10  # start at 10 (lowest barrier)

# Hardware cost penalty
if hardware_cost > 5000: barrier_score -= 4
elif hardware_cost > 1000: barrier_score -= 2
elif hardware_cost > 500: barrier_score -= 1

# Technical complexity penalty
if requires_networking_knowledge: barrier_score -= 2
if requires_custom_setup: barrier_score -= 1

# Ongoing costs penalty
if monthly_cost > 50: barrier_score -= 2
elif monthly_cost > 20: barrier_score -= 1

# Accessibility bonus
if plug_and_play: barrier_score += 1
if no_hardware_needed: barrier_score += 3  # software-only

return max(0, min(10, barrier_score))
```

**Verdict:**
- Score 8-10: **LOW BARRIER** (accessible to retail)
- Score 5-7: **MEDIUM BARRIER** (enthusiasts only)
- Score 0-4: **HIGH BARRIER** (avoid unless institutional)

### 3. Operator Economics (ROI Analysis)

**Key metrics:**
```python
# Monthly revenue per device
monthly_revenue = token_rewards_per_month * token_price

# Payback period
payback_months = hardware_cost / monthly_revenue

# Annual ROI
annual_roi = ((monthly_revenue * 12) / hardware_cost) * 100

# Benchmarks:
# Excellent: <6 months payback, >200% ROI
# Good: 6-12 months payback, 100-200% ROI
# Acceptable: 12-24 months payback, 50-100% ROI
# Poor: >24 months payback, <50% ROI
```

**Token price risk:**
- DePIN rewards are in native token
- If token drops 50%, ROI halves
- Check token volatility (ATH vs current price)

**Example calculation:**
```
Helium 5G hotspot:
- Hardware: $500
- Monthly rewards: 50 MOBILE tokens
- Token price: $0.001
- Monthly revenue: $0.05
- Payback: 10,000 months (DEAD)

Peaq machine node:
- Hardware: $0 (software-only)
- Monthly rewards: 100 PEAQ
- Token price: $0.018
- Monthly revenue: $1.80
- Payback: N/A (no hardware cost)
- But token down -97.6% from ATH (HIGH RISK)
```

### 4. Network Effects & Adoption

**Critical mass indicators:**
- How many devices/nodes currently active?
- Growth rate (MoM, YoY)?
- Geographic coverage?
- Actual usage vs speculative deployment?

**Benchmarks:**
```python
# Device count
if devices < 1000: stage = "Pre-early"
elif devices < 10000: stage = "Early"
elif devices < 100000: stage = "Growth"
else: stage = "Mature"

# Usage vs deployment
usage_ratio = (active_users / total_devices) * 100

# Healthy: >50% (real demand)
# Speculative: 10-50% (mostly farming)
# Dead: <10% (ghost network)
```

**Example:**
- Helium (peak): 1M+ hotspots, but <5% actual usage → **FARMING TRAP**
- Render: 10K+ GPUs, 80%+ utilization → **REAL DEMAND**

### 5. Tokenomics for DePIN

**Emission schedule:**
- How many tokens minted per day/month?
- What % goes to operators vs team/treasury?
- Is emission rate sustainable?

**Sell pressure calculation:**
```python
# Daily operator sell pressure
daily_operator_rewards = devices * avg_reward_per_device
daily_sell_pressure_usd = daily_operator_rewards * token_price

# Compare to daily volume
sell_pressure_ratio = (daily_sell_pressure_usd / daily_volume) * 100

# Sustainable: <10%
# Concerning: 10-30%
# Unsustainable: >30% (token will dump)
```

**Burn mechanisms:**
- Does protocol burn tokens? (usage fees, transaction fees)
- Burn rate vs emission rate?
- Net inflation or deflation?

### 6. Product Reality for DePIN

**Validation checklist:**
- ✅ Hardware available for purchase? (or waitlist?)
- ✅ Onboarding docs exist?
- ✅ Active operator community? (Discord, Telegram)
- ✅ Network map/explorer showing live devices?
- ✅ Actual customers using the service? (not just operators)

**Red flags:**
- ❌ Hardware "coming soon" for >6 months
- ❌ No network explorer (can't verify device count)
- ❌ Operator community larger than user community (farming trap)
- ❌ No proof of actual service usage

### 7. Competitive Moat

**DePIN-specific moats:**
- **Network density:** More devices = better coverage = more users (Helium's original thesis)
- **Hardware lock-in:** Proprietary hardware = switching cost (weak moat)
- **Data quality:** Better sensors/coverage = better data (Hivemapper vs Google Maps)
- **First-mover:** Established network hard to displace (but not impossible)

**Threat assessment:**
- Can Web2 incumbents do this better? (Google, AWS, Verizon)
- Can another DePIN project fork and improve?
- Is the "decentralization" actually valuable or just marketing?

### 8. DePIN-Specific Red Flags

**Ponzi indicators:**
- ❌ Rewards come from new operator deposits (not service revenue)
- ❌ No actual customers, only operators
- ❌ Emission rate >> service revenue (unsustainable)
- ❌ Token price required to stay high for ROI (circular dependency)

**Overhype indicators:**
- ❌ "Revolutionary" claims without proof
- ❌ Comparing to trillion-dollar industries (e.g., "We'll replace AWS")
- ❌ Roadmap with no delivered milestones
- ❌ Anonymous team or team with no relevant experience

### 9. DePIN Verdict Framework

**Scoring matrix:**

| Factor | Weight | Score (0-10) | Weighted |
|--------|--------|--------------|----------|
| Barrier to entry | 20% | X | X * 0.2 |
| Operator ROI | 25% | X | X * 0.25 |
| Network adoption | 20% | X | X * 0.2 |
| Tokenomics | 15% | X | X * 0.15 |
| Competitive moat | 10% | X | X * 0.1 |
| Product reality | 10% | X | X * 0.1 |

**Total score → Verdict:**
- 8-10: **FARM** (strong fundamentals, good ROI)
- 6-7.5: **WATCH** (promising but wait for better entry)
- 4-5.5: **SKIP** (too risky or poor ROI)
- 0-3.5: **AVOID** (likely farming trap or scam)

### 10. DePIN Action Plan Template

**For FARM verdict:**
```markdown
## HARDWARE SETUP
1. Purchase: [Device name] from [vendor] (~$X)
2. Setup time: X hours
3. Technical requirements: [List]

## OPERATOR ECONOMICS
- Monthly revenue: $X (at current token price)
- Payback period: X months
- Annual ROI: X%
- Risk: Token price volatility (currently -X% from ATH)

## ONGOING MAINTENANCE
- Electricity: $X/month
- Bandwidth: X GB/month
- Monitoring: [Tools/dashboards]
- Troubleshooting: [Discord/docs links]

## EXIT STRATEGY
- Sell hardware if ROI < X%
- Dump tokens if price drops below $X
- Monitor network growth (if devices drop X%, exit)
```

**For WATCH verdict:**
```markdown
## ENTRY CONDITIONS
- ✅ Token price recovers to $X (X% from current)
- ✅ Network reaches X devices (proof of adoption)
- ✅ Hardware cost drops below $X
- ✅ Operator ROI improves to >X%/year

## MONITORING
- Check monthly: [Metrics to track]
- Set alerts: [Price/network thresholds]
```

---

## Type D: NFT Collection Analysis Framework

**Use when:** Analyzing NFT collections on OpenSea, Blur, or other marketplaces (e.g., "Is Numismatis NFT worth buying?")

### 1. Current Metrics Extraction

**Primary data sources:**
- OpenSea API (if accessible)
- OpenSea web UI (via Browser Use Cloud if Cloudflare blocks)
- Blur API
- NFTScan API

**Key metrics to extract:**
```
Floor Price:     X ETH (~$Y USD)
Total Volume:    X ETH (all-time)
Total Sales:     X sales
Holders:         X unique owners
Supply:          X NFTs
Market Cap:      X ETH (floor * supply)

Trading Activity:
├─ 24h:  X ETH (Y sales) → Avg: Z ETH/sale
├─ 7d:   X ETH (Y sales) → Avg: Z ETH/sale
└─ 30d:  X ETH (Y sales) → Avg: Z ETH/sale
```

**Critical calculations:**
```python
# Volume per holder (liquidity indicator)
vol_per_holder = volume_24h / holders

# Holder concentration
holder_concentration = holders / supply  # Lower = more concentrated

# Average sale price trends
avg_sale_24h = volume_24h / sales_24h
avg_sale_7d = volume_7d / sales_7d
avg_sale_30d = volume_30d / sales_30d

# Declining avg sale = death spiral
if avg_sale_24h < avg_sale_7d < avg_sale_30d:
    trend = "DEATH_SPIRAL"
```

### 2. Historical Price Analysis

**Chart pattern recognition:**

**A. Pump & Dump Pattern** 🔴
```
Characteristics:
- Slow accumulation (0.1 → 0.2 ETH over weeks)
- Flat distribution phase (consolidation)
- Sharp pump (2-5x in days/weeks)
- Immediate crash (50-100% drop)
- Dead cat bounce (brief recovery)
- Final death spiral (continuous decline)

Example timeline:
Oct: 0.1 ETH (launch)
Dec: 0.2 ETH (accumulation)
Jan: 0.2 ETH (distribution)
Feb: 0.5 ETH (PUMP - 2.5x)
Mar: 0.0 ETH (CRASH - rug pull)
Apr: 0.4 ETH (dead cat bounce)
May: 0.003 ETH (death spiral)

Verdict: RUG PULL / ABANDONED
```

**B. Death Spiral Pattern** 🔴
```
Characteristics:
- Continuous decline with no support levels
- No consolidation zones
- No buying pressure
- Accelerating decline (e.g., -94% in 7 days)
- High sale count but tiny values (panic selling)

Indicators:
- Floor price -90%+ from peak
- No horizontal support lines on chart
- Volume declining but sale count high
- Avg sale price dropping faster than floor

Verdict: PROJECT DEAD
```

**C. Healthy Correction Pattern** ✅
```
Characteristics:
- Gradual uptrend with consolidation
- Multiple horizontal support levels
- Higher lows, higher highs
- Volume steady or increasing
- Community active during dips

Indicators:
- Floor price -20-40% from peak (normal correction)
- Clear support levels (price bounces)
- Volume/holder ratio stable
- Social media active

Verdict: HEALTHY PROJECT
```

**Price decline severity:**
```python
decline_from_peak = ((ath_price - current_price) / ath_price) * 100

# Classification:
if decline > 95: severity = "TERMINAL"      # Project dead
elif decline > 80: severity = "CRITICAL"    # Likely abandoned
elif decline > 60: severity = "SEVERE"      # Major issues
elif decline > 40: severity = "MODERATE"    # Normal bear market
else: severity = "HEALTHY"                  # Normal volatility
```

### 3. Project Fundamentals Assessment

**Basic info checklist:**
```
Name:       [Collection name]
Concept:    [What is it? Art? Utility? PFP?]
Contract:   [Ethereum address]
Launched:   [Date] (X months ago)
Website:    [URL] ✅/❌
Twitter:    [@handle] (X followers) ✅/❌
Discord:    [Link] (X members) ✅/❌
Telegram:   [Link] ✅/❌
Status:     OpenSea Verified ✅/❌
```

**Team & development:**
```
Team:       ✅ Doxxed / ❌ Anonymous
Roadmap:    ✅ Exists / ❌ None
Updates:    ✅ Regular / ⚠️ Sporadic / ❌ None
Social:     ✅ Active / ⚠️ Declining / ❌ Dead
Community:  ✅ Engaged / ⚠️ Quiet / ❌ Ghost town
```

**Utility assessment:**
```
Staking:        ✅/❌
Rewards:        ✅/❌
Ecosystem:      ✅/❌ (DAO, token, metaverse, etc.)
Partnerships:   ✅/❌
Real Benefits:  ✅/❌ (IRL utility, access, etc.)
Use Case:       [Description or "None"]

Verdict: [STRONG UTILITY / WEAK UTILITY / ZERO UTILITY]
```

### 4. Red Flag Detection (NFT-Specific)

**10 Major Warning Signs:**

**1. Catastrophic Floor Price** 🔴
```
Floor < $10 = Dead project territory
Floor < $50 = Severe distress
Floor < $100 = Concerning (depends on mint price)

Context matters: If mint was $100 and floor is $5 = -95% = DEAD
```

**2. Abandoned Community** 🔴
```
Twitter followers < 1K after 6+ months = DEAD
No Discord/Telegram = ABANDONED
Last tweet > 1 month ago = INACTIVE
Discord last message > 1 week ago = GHOST TOWN
```

**3. Zero Market Cap** 🔴
```
If OpenSea reports 0.0 ETH market cap = NO VALUE
```

**4. No Development** 🔴
```
No roadmap updates = ABANDONED
No new features/utilities = STAGNANT
No team communication = RUG PULL
```

**5. Suspicious Volume** 🔴
```
High sale count but low total volume = WASH TRADING or PANIC SELLING

Example:
- 129 sales/day but only 1.1 ETH total
- Avg: 0.0085 ETH/sale ($20)
- Pattern: Desperate holders dumping at any price
```

**6. Poor Holder Distribution** 🔴
```
Holders / Supply < 60% = High concentration risk

Example:
- 285 holders / 547 supply = 52%
- Many holders own multiple NFTs
- Whales can dump and crash floor
```

**7. No Utility** 🔴
```
Just collectible, no use case = WEAK VALUE PROP
No staking, rewards, or benefits = NO REASON TO HOLD
```

**8. Declining Momentum** 🔴
```
All metrics trending DOWN:
├─ Price: -X% from 30d avg
├─ Volume: Declining
├─ Holders: Decreasing
└─ Community: Shrinking

Trend: DEATH SPIRAL
```

**9. Fast Death** 🔴
```
Launched < 12 months ago but already dead = EXTREMELY FAST FAILURE

Example:
- Launched: Aug 2025
- Dead by: May 2026 (9 months)
- Speed: RED FLAG (most projects take 18-24 months to die)
```

**10. No Recovery Catalysts** 🔴
```
No team announcements = NO HOPE
No roadmap updates = NO FUTURE
No partnerships = NO GROWTH
No utility additions = NO VALUE
No community growth = NO BUYERS

Recovery Chance: ~5% (near zero)
```

### 5. Positive Signals (Rare in Dying Projects)

**What to look for:**
```
✅ OpenSea Verified (but doesn't save dying project)
✅ Website still online (but check last update)
✅ Unique concept (but execution matters more)
✅ Very cheap entry (but cheap for a reason)
✅ Complete collection minted (but doesn't mean success)
✅ Active Discord (>100 messages/day)
✅ Regular team updates (weekly or more)
✅ Partnerships announced (with proof)
✅ Utility roadmap (with delivered milestones)
✅ Community events (spaces, AMAs, giveaways)
```

**Note:** In dying projects, positives are usually MEANINGLESS compared to negatives.

### 6. Risk Assessment Framework

**Risk Level Calculation:**
```python
risk_score = 0  # Start at 0 (lowest risk)

# Price risk
if floor_decline > 95: risk_score += 4
elif floor_decline > 80: risk_score += 3
elif floor_decline > 60: risk_score += 2
elif floor_decline > 40: risk_score += 1

# Liquidity risk
if volume_24h < 1: risk_score += 3  # <1 ETH/day = CRITICAL
elif volume_24h < 5: risk_score += 2
elif volume_24h < 10: risk_score += 1

# Community risk
if no_discord_telegram: risk_score += 2
if twitter_followers < 1000: risk_score += 1
if last_update > 30_days: risk_score += 2

# Development risk
if no_roadmap: risk_score += 1
if no_utility: risk_score += 1

# Total risk (0-10 scale)
risk_level = min(10, risk_score)

# Classification:
if risk_level >= 8: return "EXTREME"
elif risk_level >= 6: return "HIGH"
elif risk_level >= 4: return "MEDIUM"
else: return "LOW"
```

**Scenario Probability Estimation:**
```python
# Best case (recovery)
if risk_level >= 8:
    best_case_prob = 5  # 5% chance
    best_case_gain = "3-5x"
elif risk_level >= 6:
    best_case_prob = 15
    best_case_gain = "2-3x"
else:
    best_case_prob = 30
    best_case_gain = "1.5-2x"

# Most likely (continued decline)
most_likely_prob = 100 - best_case_prob - 15  # Reserve 15% for worst case
most_likely_outcome = "50-90% more loss"

# Worst case (complete death)
worst_case_prob = 15
worst_case_outcome = "100% loss"
```

### 7. NFT Verdict Framework

**Verdict options:**
- **BUY (SEROK)**: Strong fundamentals, healthy chart, active community, clear utility
- **HOLD**: Already own, project still has potential, wait for recovery
- **AVOID (JANGAN SEROK)**: Death spiral, abandoned project, no recovery chance
- **WATCH**: Interesting but wait for better entry or more data

**Decision matrix:**

| Floor Decline | Volume | Community | Utility | Verdict |
|---------------|--------|-----------|---------|---------|
| <40% | >10 ETH/day | Active | Strong | BUY |
| 40-60% | 5-10 ETH/day | Moderate | Weak | WATCH |
| 60-80% | 1-5 ETH/day | Declining | None | AVOID |
| >80% | <1 ETH/day | Dead | None | AVOID |

**Special case: Death spiral pattern detected**
```
If chart shows:
- Pump & dump pattern (Feb peak → Mar crash)
- -90%+ decline in <3 months
- No support levels
- Volume declining but sale count high

→ VERDICT: AVOID (regardless of other factors)
→ REASON: "Ini bukan dip, ini project mati"
```

### 8. Output Format (Indonesian Style)

**User prefers:**
- Direct verdict upfront (JANGAN SEROK / SEROK)
- Concise explanations (no fluff)
- Data-driven reasoning
- Clear risk assessment
- Specific numbers (not ranges)

**Template:**
```markdown
# 🔴 [COLLECTION NAME] — ANALISA MENDALAM

## 🎯 JAWABAN SINGKAT

### **"Lagi dump, apakah kita serok?"**

# ❌ **JANGAN SEROK!**

**Ini bukan dip, ini project MATI!** 💀

---

## 📊 CURRENT METRICS (Date)

```
Floor Price:    X ETH (~$Y USD)
Total Volume:   X ETH (all-time)
Total Sales:    X sales
Holders:        X unique owners
Supply:         X NFTs
Market Cap:     X ETH

Trading Activity:
├─ 24h:  X ETH (Y sales) → Avg: Z ETH/sale
├─ 7d:   X ETH (Y sales) → Avg: Z ETH/sale
└─ 30d:  X ETH (Y sales) → Avg: Z ETH/sale
```

---

## 📉 HISTORICAL ANALYSIS

**Price Trends:**
```
Current Floor:     X ETH ($Y)
30-day Average:    X ETH ($Y)
Decline:           -X% ⚠️⚠️⚠️

Status: [DEATH SPIRAL / HEALTHY CORRECTION / etc.]
```

**Chart Pattern:** [Pump & Dump / Death Spiral / Healthy]

**Timeline:**
```
[Month] [Year]:  ~X ETH    ([Stage])
[Month] [Year]:  ~X ETH    ([Stage])
...
[Month] [Year]:  X ETH     ← NOW

Trend: [↓↓↓ CONTINUOUS DECLINE / ↑ RECOVERY / etc.]
```

---

## 🏢 PROJECT FUNDAMENTALS

**Basic Info:**
```
Name:       [Name]
Concept:    [Description]
Contract:   [Address]
Launched:   [Date] (X months ago)
Website:    [URL] ✅/❌
Twitter:    [@handle] (X followers) ✅/❌
Discord:    [Link] ✅/❌
Status:     OpenSea Verified ✅/❌
```

**Team & Development:**
```
Team:       ✅/❌
Roadmap:    ✅/❌
Updates:    ✅/❌
Social:     ✅/⚠️/❌
Community:  ✅/⚠️/❌
```

**Utility:**
```
[List of utilities or "ZERO UTILITY"]
```

---

## 🚩 RED FLAGS (X MAJOR WARNINGS)

### **1. [Red Flag Name]** 🔴
```
[Description with data]
```

[Repeat for each red flag]

---

## ✅ POSITIVE SIGNALS (Minimal/None)

```
[List positives or "NONE"]
```

**Note:** [Context on why positives don't matter]

---

## ⚖️ RISK ASSESSMENT

**Risk Level: 🔴 [EXTREME / HIGH / MEDIUM / LOW] (X/10)**

**Scenarios:**

**1. Best Case (X% probability):**
```
[Description]
Gain: Xx from current price
Likelihood: [VERY LOW / LOW / MODERATE / HIGH]
```

**2. Most Likely (X% probability):**
```
[Description]
Loss: -X% more from current
Status: [Description]
Likelihood: [VERY HIGH / HIGH / MODERATE]
```

**3. Worst Case (X% probability):**
```
[Description]
Loss: -100% of investment
Status: [Description]
Likelihood: [HIGH / MODERATE / LOW]
```

**Risk Factors:**
```
Liquidity:          🔴 [CRITICAL / HIGH / MEDIUM / LOW]
Abandonment:        🔴 [HIGH / MEDIUM / LOW]
Price Decline:      🔴 [CRITICAL / SEVERE / MODERATE]
Recovery Potential: 🔴 [NEAR ZERO / LOW / MEDIUM / HIGH]
Community:          🔴 [DEAD / DECLINING / ACTIVE]
Utility:            🔴 [NONE / WEAK / STRONG]
Development:        🔴 [ABANDONED / SLOW / ACTIVE]
```

**Overall Risk:** 🔴 **[VERDICT]**

---

## 🎯 FINAL RECOMMENDATION

# ❌ **[AVOID / BUY / HOLD / WATCH] — [REASON]**

**WHY NOT TO BUY:** (if AVOID)

**1. [Reason 1]**
```
[Explanation with data]
```

[Repeat for each reason]

**WHAT TO DO:**

**If you HOLD [Collection]:**
```
❌ [Action 1]
❌ [Action 2]
✅ [Recommended action]
```

**If you're CONSIDERING buying:**
```
❌ [What not to do]
✅ [What to do instead]
```

**Better alternatives:**
```
[List of better NFT projects or strategies]
```

---

## 📝 CONCLUSION

**[Collection Name] = [VERDICT]**

**Signs of [Status]:**
- ✅ [Sign 1]
- ✅ [Sign 2]
- ✅ [Sign 3]

---

# 🇮🇩 FINAL ANSWER:

## ❌ **[VERDICT IN INDONESIAN]**

**[Concise explanation in Indonesian]**

**[Collection] = 💀 [STATUS]**

**Recovery chance: X%**  
**Loss risk: X%**

**Verdict: [FINAL VERDICT]** 🔴

---

**Disclaimer:** Not financial advice. DYOR.

**Analysis Date:** [Date]  
**Data Sources:** [OpenSea, Twitter, etc.]
```

### 9. Data Gathering for NFTs

**Primary method: Browser Use Cloud API**

**Why Browser Use over Scrapling:**
- ✅ Zero disk usage (cloud-based)
- ✅ Zero RAM usage (no local browser)
- ✅ Bypasses Cloudflare automatically
- ✅ Stealth browser (forked Chromium)
- ✅ Residential proxies built-in
- ❌ Pay per use (but worth it for VPS with limited resources)

**Scrapling comparison:**
- ❌ 650-900 MB disk
- ❌ 200-400 MB RAM per browser session
- ❌ Too heavy for 2GB RAM VPS
- ✅ Free (self-hosted)

**Verdict:** Use Browser Use Cloud for NFT scraping on resource-constrained VPS.

**API endpoint:**
```bash
# Create session
curl -X POST "https://api.browser-use.com/v3/sessions" \
  -H "X-Browser-Use-API-Key: bu_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://opensea.io/collection/{slug}/analytics",
    "task": "Extract floor price, volume (24h/7d/30d), holders, supply, recent sales",
    "model": "gpt-4o-mini",
    "max_steps": 15
  }'

# Poll for result
curl -X GET "https://api.browser-use.com/v3/sessions/{session_id}" \
  -H "X-Browser-Use-API-Key: bu_..."
```

**Fallback if Browser Use unavailable:**
- OpenSea API (if accessible)
- Blur API
- NFTScan API
- Manual user screenshot (ask user to provide data)

**See:** `references/browser-use-cloud.md` for full API documentation and self-registration flow.

**Polymarket bot ecosystem:** See `references/polymarket-bots-ecosystem.md` for comprehensive analysis of 20+ trading bot repositories, strategies, and tech stacks.

### 10. Common Pitfalls (NFT-Specific)

**Pitfall 1: "Cheap = Good Deal" Fallacy**

**Problem:** Low floor price doesn't mean undervalued

**Solution:** Check WHY it's cheap:
- Project abandoned? (team gone, no updates)
- No utility? (just art, no use case)
- No community? (Discord dead, Twitter inactive)
- Death spiral? (continuous decline, no support)

**Example:**
- Floor $5 but project dead = NOT A DEAL
- Floor $500 but active community + utility = POTENTIALLY GOOD

**Pitfall 2: "High Volume = Healthy" Fallacy**

**Problem:** High sale count doesn't mean healthy project

**Solution:** Check average sale price:
```python
avg_sale = volume / sale_count

if avg_sale < floor_price * 0.5:
    # People selling below floor = PANIC
    status = "DEATH_SPIRAL"
```

**Example:**
- 129 sales/day, 1.1 ETH volume = Avg $20/sale
- Floor is $8 = People dumping at any price
- Status: PANIC SELLING, not healthy volume

**Pitfall 3: "OpenSea Verified = Safe" Fallacy**

**Problem:** Verification doesn't prevent rug pulls

**Solution:** Verify badge only confirms identity, not quality:
- Check team activity (Twitter, Discord)
- Check development (roadmap progress)
- Check community (engagement, not just size)

**Pitfall 4: Ignoring Chart Patterns**

**Problem:** Focusing only on current price, not trend

**Solution:** Always check historical chart:
- Pump & dump pattern = RUG PULL
- Death spiral = ABANDONED
- Healthy correction = TEMPORARY DIP

**User provided chart showing pump & dump:**
- Feb peak (0.5 ETH) → Mar crash (0.0 ETH) → Apr bounce (0.4 ETH) → May death (0.003 ETH)
- Pattern: TEXTBOOK RUG PULL
- Verdict: AVOID (not a dip, project dead)

**Pitfall 5: "High Risk = High Reward" Fallacy**

**Problem:** Assuming dying project = opportunity

**Solution:** Calculate expected value:
```python
expected_value = (prob_gain * gain) + (prob_loss * loss)

# Example (dying NFT):
# 5% chance of 3x = +0.15
# 95% chance of -90% = -0.855
# Expected value = -0.705 (NEGATIVE!)

if expected_value < 0:
    verdict = "AVOID"  # You WILL lose money on average
```

**Pitfall 6: Resource Constraints (VPS-Specific)**

**Problem:** User rejected Scrapling immediately: "gede banget makan emori dan ram"

**Lesson:** On 2GB RAM VPS, user has ZERO tolerance for heavy tools:
- 650-900 MB disk = INSTANT REJECTION
- 200-400 MB RAM = INSTANT REJECTION
- "gede banget" = STOP, don't try to convince

**Solution:** Always check resource impact BEFORE recommending tools:
- Disk: <100 MB = OK, >500 MB = ASK FIRST
- RAM: <50 MB = OK, >100 MB = ASK FIRST
- If user says "gede banget" = IMMEDIATELY pivot to lightweight alternative

**Alternative for NFT scraping:**
- Browser Use Cloud (0 MB disk, 0 MB RAM) ✅
- OpenSea API (0 MB disk, 0 MB RAM) ✅
- Ask user for screenshot (0 MB disk, 0 MB RAM) ✅

---

## Real-Time Data Gathering (X/Twitter)

---

## Real-Time Data Gathering Techniques

### X/Twitter Data (fxtwitter API)

**Primary tool: fxtwitter API** (no auth required, works from terminal)

**Get Tweet Data:**
```bash
# Single tweet
curl -s "https://api.fxtwitter.com/{handle}/status/{tweet_id}" | jq -r '.tweet | {text, created_at, likes, retweets, replies, author: .author.name}'

# With media check
curl -s "https://api.fxtwitter.com/{handle}/status/{tweet_id}" | jq -r '.tweet | {text, likes, retweets, has_media: (.media != null), media_count: (.media | length)}'
```

**Note:** Use `.author.name` not `.author.screen_name` for display name.

**Get Account Info:**
```bash
curl -s "https://api.fxtwitter.com/{handle}" | jq -r '.user | {name, description, followers, following, tweets, verified}'
```

**Engagement Analysis:**
```python
# Calculate engagement rate
engagement_rate = ((likes + retweets + replies) / followers) * 100

# Benchmarks:
# Excellent: >5%
# Good: 2-5%
# Normal: 1-2%
# Weak: 0.5-1%
# Dead: <0.5%
```

**Fallback if fxtwitter blocked:**
- Try vxtwitter.com (same API structure)
- Try fixupx.com
- Use web search: `curl -s "https://duckduckgo.com/html/?q=site:twitter.com+{query}"`

### GitHub Data

**Organization repos:**
```bash
curl -s "https://api.github.com/orgs/{project}/repos" | jq -r '.[0:5] | .[] | {name, description, stars: .stargazers_count, updated: .updated_at}'
```

**Specific repo details:**
```bash
curl -s "https://api.github.com/repos/{org}/{repo}" | jq -r '{name, stars: .stargazers_count, forks, created_at, updated_at, language}'
```

**Recent activity check:**
```bash
curl -s "https://api.github.com/repos/{org}/{repo}/commits?per_page=5" | jq -r '.[] | {date: .commit.author.date, message: .commit.message}'
```

### CoinGecko Data

**Step 1: Search for token ID**

```bash
# Search by name/symbol
curl -s "https://api.coingecko.com/api/v3/search?query={token_name}" | jq -r '.coins[] | select(.name | test("Token"; "i")) | {id, symbol, name, market_cap_rank}'
```

**Step 2: Get comprehensive market data**

```bash
# Full market data (single call)
curl -s "https://api.coingecko.com/api/v3/coins/{token_id}?localization=false&tickers=false&market_data=true&community_data=true&developer_data=true" | jq '{
  price: .market_data.current_price.usd,
  mcap: .market_data.market_cap.usd,
  fdv: .market_data.fully_diluted_valuation.usd,
  volume_24h: .market_data.total_volume.usd,
  circulating: .market_data.circulating_supply,
  total: .market_data.total_supply,
  max: .market_data.max_supply,
  ath: .market_data.ath.usd,
  ath_date: .market_data.ath_date.usd,
  atl: .market_data.atl.usd,
  atl_date: .market_data.atl_date.usd,
  price_change_24h: .market_data.price_change_percentage_24h,
  price_change_7d: .market_data.price_change_percentage_7d,
  price_change_30d: .market_data.price_change_percentage_30d,
  twitter: .community_data.twitter_followers,
  github_stars: .developer_data.stars,
  github_forks: .developer_data.forks,
  commits_4w: .developer_data.commit_count_4_weeks
}'
```

**Step 3: Get exchange liquidity data**

```bash
# Top exchanges with spread data
curl -s "https://api.coingecko.com/api/v3/coins/{token_id}/tickers?depth=true" | jq '[.tickers[] | {exchange: .market.name, pair: (.base + "-" + .target), volume_usd: .converted_volume.usd, spread: .bid_ask_spread_percentage}] | .[0:5]'
```

**Step 4: Get project links**

```bash
curl -s "https://api.coingecko.com/api/v3/coins/{token_id}" | jq -r '.links | {homepage: .homepage[0], twitter: .twitter_screen_name, telegram: .telegram_channel_identifier, github: .repos_url.github[0]}'
`

…(truncated)