# AI Token Sector Tracker (`gochujang/ai-token-sector-tracker`) Actor

Track the AI/Agent crypto token ecosystem. Returns market cap, volume, price changes for AI-category tokens across multiple CoinGecko categories. Includes sector summary and top movers.

- **URL**: https://apify.com/gochujang/ai-token-sector-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Business
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 token returneds

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 AI Token Sector Tracker do?

**AI Token Sector Tracker** is an Apify actor that pulls real-time market data for every token in the **artificial intelligence crypto** universe — covering `artificial-intelligence`, `ai-agents`, `decentralized-ai`, and `large-language-model` categories from CoinGecko. Each run returns price, **AI crypto market cap**, 24h/7d/30d performance, and sector-level dominance metrics. No API key required.

This actor is the fastest way to answer "how is the AI token sector performing right now?" — in a single pull you get individual token data plus an aggregate SUMMARY record showing total sector market cap, AI sector dominance percentage vs. the whole crypto market, and top movers.

### Why use AI Token Sector Tracker?

The **AI crypto** sector rotates independently from BTC and ETH. When narrative heats up — model launches, agent frameworks going live, VC rounds — **AI tokens** can move 2–5× faster than the broader market. Tracking them manually across dozens of individual coin pages is impractical.

**Business use cases:**

1. **Sector rotation signals** — Compare `sector_avg_change_24h` against BTC performance. A sustained 2× outperformance signals active rotation into **artificial intelligence crypto** assets.
2. **Narrative alert systems** — Schedule daily runs and trigger alerts when `ai_dominance_pct` shifts by ±0.5%, indicating major capital flow changes.
3. **Early breakout detection** — Sort by `price_change_24h_desc` to surface **AI token** breakouts before they appear in mainstream feeds.
4. **Portfolio benchmarking** — Measure your AI holdings against the sector average to evaluate relative performance.
5. **Liquidity screening** — Filter by `minVolume24hUsd` to exclude illiquid micro-cap **AI coins** that carry outsized execution risk.

### How to use AI Token Sector Tracker

1. Open the actor on Apify and click **Start** — default settings return top 50 tokens per category, deduplicated, in USD.
2. (Optional) Adjust `categories` to focus on a specific sub-sector (e.g., only `ai-agents`).
3. (Optional) Set `minMarketCapUsd` or `minVolume24hUsd` to filter out low-quality tokens.
4. (Optional) Change `sortBy` to `price_change_24h_desc` to rank by momentum.
5. The dataset populates in ~10 seconds. The key-value store also receives a `SUMMARY` record with aggregate sector stats.

### Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `categories` | array | all 4 AI categories | CoinGecko category IDs to fetch |
| `vsCurrency` | string | `usd` | Quote currency (`usd`, `btc`, `eth`) |
| `perPage` | integer | `50` | Max tokens per category (max 250) |
| `sortBy` | string | `market_cap_desc` | Sort: `market_cap_desc`, `volume_desc`, `price_change_24h_desc`, `price_change_24h_asc` |
| `minMarketCapUsd` | number | `0` | Filter: min market cap in USD |
| `minVolume24hUsd` | number | `0` | Filter: min 24h volume in USD |
| `deduplicate` | boolean | `true` | Remove duplicate tokens across categories |
| `includeGlobalContext` | boolean | `true` | Compute **AI sector dominance** vs. global market cap |

### Output

Each dataset item represents one **AI token** with full market metrics:

```json
[
  {
    "rank": 1,
    "symbol": "TAO",
    "name": "Bittensor",
    "category": "decentralized-ai",
    "price_usd": 312.45,
    "market_cap_usd": 2280000000,
    "volume_24h_usd": 145000000,
    "price_change_24h_pct": 6.82,
    "price_change_7d_pct": 18.4,
    "price_change_30d_pct": 54.1,
    "volume_to_mcap": 0.064,
    "ath_change_pct": -52.3
  },
  {
    "rank": 2,
    "symbol": "FET",
    "name": "Fetch.ai",
    "category": "artificial-intelligence",
    "price_usd": 1.23,
    "market_cap_usd": 3100000000,
    "volume_24h_usd": 85000000,
    "price_change_24h_pct": 8.32,
    "price_change_7d_pct": -3.1,
    "price_change_30d_pct": 42.5,
    "volume_to_mcap": 0.027,
    "ath_change_pct": -68.4
  }
]
```

The key-value store `SUMMARY` record includes:

```json
{
  "sector_total_mcap_usd": 42800000000,
  "sector_total_volume_24h": 3210000000,
  "sector_avg_change_24h": 4.7,
  "ai_dominance_pct": 2.14,
  "top5_gainers_24h": ["TAO", "WLD", "RENDER", "NEAR", "OCEAN"],
  "top5_losers_24h": ["NMR", "AGIX", "GRT", "AI16Z", "AIXBT"]
}
```

### Data fields

| Field | Example | Description |
|---|---|---|
| `symbol` | `FET` | Token ticker symbol |
| `name` | `Fetch.ai` | Full token name |
| `category` | `artificial-intelligence` | CoinGecko **AI token** category |
| `price_usd` | `1.23` | Current price in USD |
| `market_cap_usd` | `3100000000` | **AI crypto market cap** |
| `volume_24h_usd` | `85000000` | 24h trading volume |
| `price_change_24h_pct` | `8.32` | % price change vs. 24h ago |
| `price_change_7d_pct` | `-3.1` | % price change vs. 7 days ago |
| `price_change_30d_pct` | `42.5` | % price change vs. 30 days ago |
| `volume_to_mcap` | `0.027` | Volume/market cap ratio — liquidity signal |
| `ath_change_pct` | `-68.4` | % decline from all-time high |

### Cost estimation

**Pay-Per-Event: $0.001 per token returned.**

| Run type | Tokens returned | Estimated cost |
|---|---|---|
| Default (4 categories × 50, deduped) | ~80 tokens | **$0.08** |
| Single category, top 50 | 50 tokens | **$0.05** |
| All categories, 250 each | ~300 tokens | **$0.30** |
| Large-cap filter only | 10–30 tokens | **$0.01–$0.03** |

Scheduling daily runs to track the **AI token sector** costs roughly $0.50–1.00/month at default settings.

### FAQ

**Q: What data source does this actor use?**
A: All data comes from the [CoinGecko Public API](https://www.coingecko.com/en/api) — no API key required. CoinGecko updates prices and market cap approximately every 60 seconds.

**Q: Which AI token categories are covered?**
A: Four CoinGecko categories: `artificial-intelligence` (FET, TAO, RENDER, NEAR, GRT, WLD), `ai-agents` (VIRTUAL, AI16Z, AIXBT, GOAT), `decentralized-ai` (OCEAN, NMR, AGIX), and `large-language-model` (on-chain LLM infrastructure tokens). You can restrict to any subset via the `categories` input.

**Q: Can I run this on a schedule to monitor AI sector trends?**
A: Yes — use Apify's built-in scheduler to run hourly, daily, or on any cron schedule. Results accumulate in the dataset for trend analysis over time.

> **Disclaimer:** This actor provides market data for informational purposes only. It does not constitute financial advice. **AI crypto market cap** data reflects public exchange prices and may differ across sources. Always verify with multiple sources before making investment decisions.

**Keywords:** AI token sector tracker, artificial intelligence crypto, AI crypto market cap, AI agents tokens, decentralized AI, LLM tokens, CoinGecko AI category, AI sector dominance, crypto token performance, AI coin tracker, sector rotation crypto

***

### Related actors

- [Crypto Sector Rotation](https://apify.com/gochujang/crypto-sector-rotation) — Broad crypto sector momentum to see where AI tokens rank among all categories
- [Crypto Category Screener](https://apify.com/gochujang/crypto-category-screener) — Full CoinGecko category rankings to benchmark AI sector performance against others
- [Crypto Trending Tracker](https://apify.com/gochujang/crypto-trending-tracker) — CoinGecko trending coins including AI tokens gaining search momentum

### Feedback

If this actor powers your AI crypto research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/ai-token-sector-tracker#reviews)

# Actor input Schema

## `categories` (type: `array`):

CoinGecko category IDs to fetch. Defaults to all 4 AI categories.

## `vsCurrency` (type: `string`):

Currency for prices and market cap (e.g. usd, btc, eth).

## `perPage` (type: `integer`):

Max tokens to fetch per category (max 250).

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

Sort order for output rows.

## `minMarketCapUsd` (type: `number`):

Filter out tokens below this market cap.

## `minVolume24hUsd` (type: `number`):

Filter out tokens below this 24h volume.

## `deduplicate` (type: `boolean`):

Remove tokens that appear in multiple categories (keeps first occurrence by market cap).

## `includeGlobalContext` (type: `boolean`):

Fetch global crypto market cap to compute AI sector dominance %.

## Actor input object example

```json
{
  "categories": [
    "artificial-intelligence",
    "ai-agents",
    "decentralized-ai",
    "large-language-model"
  ],
  "vsCurrency": "usd",
  "perPage": 50,
  "sortBy": "market_cap_desc",
  "minMarketCapUsd": 0,
  "minVolume24hUsd": 0,
  "deduplicate": true,
  "includeGlobalContext": true
}
```

# 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 = {
    "categories": [
        "artificial-intelligence",
        "ai-agents",
        "decentralized-ai",
        "large-language-model"
    ],
    "vsCurrency": "usd"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/ai-token-sector-tracker").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 = {
    "categories": [
        "artificial-intelligence",
        "ai-agents",
        "decentralized-ai",
        "large-language-model",
    ],
    "vsCurrency": "usd",
}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/ai-token-sector-tracker").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 '{
  "categories": [
    "artificial-intelligence",
    "ai-agents",
    "decentralized-ai",
    "large-language-model"
  ],
  "vsCurrency": "usd"
}' |
apify call gochujang/ai-token-sector-tracker --silent --output-dataset

```

## MCP server setup

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

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/bRbc78TjZB8zbT5yG/builds/mk6QcLAa7hfz7gP9a/openapi.json