# FOMO Token Discovery Scraper (`muhammetakkurtt/fomo-token-discovery-scraper`) Actor

Scrape crypto token lists from FOMO (fomo.family) — trending, most held, graduated, pre-graduated, community, verified and top crypto — each with price, market cap, liquidity, volume, holders, momentum and launchpad data.

- **URL**: https://apify.com/muhammetakkurtt/fomo-token-discovery-scraper.md
- **Developed by:** [Muhammet Akkurt](https://apify.com/muhammetakkurtt) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 token scrapeds

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/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

![FOMO Token Discovery Scraper — trending, graduated, most held and verified crypto tokens from fomo.family](https://i.postimg.cc/P5yx9Qpg/fomo-banner.png)

## FOMO Token Discovery Scraper

**Scrape crypto token lists from FOMO (fomo.family) — trending, most held, graduated, pre-graduated, community, verified and top crypto tokens — in one actor.** Each token comes with price, market cap, liquidity, 24h volume, holders, 24h change, launchpad/graduation data and optional short-term momentum, volume and transaction activity.

No coding needed. Pick a list, click **Start**, and download the results as JSON, CSV, Excel, XML, HTML or RSS.

### What is FOMO (fomo.family)?

FOMO is a social crypto copy-trading app with curated token discovery feeds — trending coins, most-held tokens, freshly graduated launches and verified projects across Solana, Base and more. The **FOMO Token Discovery Scraper** turns those feeds into structured data for research, screening and automation.

### Token lists you can scrape

| List (`listType`) | What it returns |
|---|---|
| `trending` | Trending tokens right now |
| `mostHeld` | Tokens held by the most users |
| `graduated` | Tokens that graduated from their launchpad |
| `preGraduated` | Tokens close to graduating (early plays) |
| `community` | Community tokens |
| `crypto` | Curated major cryptocurrencies |
| `verified` | Verified tokens (the largest list) |

### What data does it extract?

| Field | Description |
|---|---|
| **Symbol / Name** | Token ticker and name |
| **Token Address / Network** | On-chain address and network id |
| **Price (USD)** | Current price |
| **Market Cap / Liquidity** | Market cap and liquidity in USD |
| **Volume 24h** | 24-hour trading volume |
| **Change 24h** | 24-hour price change |
| **Holders** | Number of holders |
| **Supply** | Circulating and total supply |
| **Launchpad / Graduation %** | Launchpad name and graduation progress |
| **Socials** | Twitter, Telegram, website |
| **Momentum (optional)** | Price change and volume over 5m / 1h / 4h / 12h |
| **Activity (optional)** | Transactions, buys/sells and unique buyers/sellers over 1h / 4h / 12h / 24h |
| **Top 10 Holders % (optional)** | Share of supply held by the top 10 holders |
| **Markets (optional)** | Exchanges and DEX protocol |

### How to use it (step by step)

1. Open the [FOMO Token Discovery Scraper](https://apify.com/muhammetakkurtt/fomo-token-discovery-scraper) on Apify Store and click **Try for free**
2. Pick a **Token List** (trending, most held, graduated, verified, …)
3. Choose the **Networks** (Solana, Base, BSC, Ethereum)
4. Optionally set **Max Tokens**, a **Search Phrase**, or toggle **Enrich With Momentum & Activity**
5. Click **Start** and export as **JSON**, **CSV**, **Excel**, **XML**, **HTML**, or **RSS**

#### Example input

```json
{
  "listType": "trending",
  "networks": ["base", "solana"],
  "enrich": true
}
```

#### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `listType` | String | No | `trending` | Which list: `trending`, `mostHeld`, `graduated`, `preGraduated`, `community`, `crypto`, `verified`. |
| `networks` | Array | No | `["base","solana"]` | Networks to include: `solana`, `base`, `bsc`, `ethereum`. |
| `limit` | Integer | No | — | Max tokens to return (up to 100). |
| `search` | String | No | — | Search tokens by name/symbol instead of fetching a list. |
| `enrich` | Boolean | No | `true` | Add 5m/1h/4h/12h price change and volume, transaction and buy/sell counts, top-10 holder share, exchanges and DEX protocol to each token. |

### Output example

> The output is the raw structure returned by FOMO (fields as-is; some are nested).

```json
{
  "listType": "trending",
  "priceUSD": "0.0477",
  "marketCap": "44871766",
  "liquidity": "52023",
  "volume24": "6768794",
  "change24": "215.2",
  "holders": 5010,
  "token": {
    "address": "Dz9mQ9Nz...bonk",
    "networkId": 1399811149,
    "name": "USELESS COIN",
    "symbol": "USELESS",
    "info": { "imageSmallUrl": "https://token-media.defined.fi/...", "totalSupply": "999940362" },
    "launchpad": { "launchpadName": "bonk", "graduationPercent": 100 }
  },
  "change5m": "0.63",
  "volume1": "94881",
  "txnCount24": 812,
  "exchanges": [ { "name": "Raydium" } ]
}
```

### Use cases

- **Memecoin & launchpad screening** — catch tokens as they graduate or trend, with liquidity, holders and graduation %
- **Market intelligence** — track most-held and community tokens over time
- **Alpha & automation** — feed discovery data into bots, dashboards and alerts via the [Apify API](https://docs.apify.com/api/v2), [schedules](https://docs.apify.com/platform/schedules) and [webhooks](https://docs.apify.com/platform/integrations/webhooks)

Connect the output to [Google Sheets](https://apify.com/integrations/google-sheets), [Slack](https://apify.com/integrations/slack), [Make](https://apify.com/integrations/make), and [many more](https://apify.com/integrations).

### Frequently asked questions

#### Which token lists are supported?

Trending, most held, graduated, pre-graduated, community, verified and curated top crypto — selectable with the `listType` parameter.

#### Which blockchains are covered?

Solana, Base, BSC and Ethereum. Most lists are Solana-heavy, and Base returns data too; you choose which networks to include.

#### How many tokens does it return?

Each list returns up to 100 tokens (the verified list can be larger). Use `limit` to return fewer.

#### Can I search for a specific token?

Yes. Set a `search` phrase to find tokens by name or symbol.

#### How do I get support?

Open an issue on the [Issues tab](https://apify.com/muhammetakkurtt/fomo-token-discovery-scraper/issues) of the actor page, or contact the developer for a custom scraping solution.

# Actor input Schema

## `listType` (type: `string`):

Which FOMO token list to scrape.

## `networks` (type: `array`):

Blockchains to include. Most lists are Solana-heavy; Base also returns data.

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

Cap the number of tokens returned (max 100 per list).

## `search` (type: `string`):

Optional. If set, search tokens by name/symbol instead of fetching a list.

## `enrich` (type: `boolean`):

Add short-term price change and volume (5m / 1h / 4h / 12h), transaction, buy/sell and unique trader counts (1h / 4h / 12h / 24h), top-10 holder share, exchanges and DEX protocol for each token.

## `proxyConfiguration` (type: `object`):

Proxy configuration (optional).

## Actor input object example

```json
{
  "listType": "trending",
  "networks": [
    "base",
    "solana"
  ],
  "enrich": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Collected FOMO tokens, one item per token

# 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("muhammetakkurtt/fomo-token-discovery-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("muhammetakkurtt/fomo-token-discovery-scraper").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 muhammetakkurtt/fomo-token-discovery-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammetakkurtt/fomo-token-discovery-scraper"
        }
    }
}
```

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/nkseCRRwh0u5phpfu/builds/1PNwu8hudky7q8xbR/openapi.json