# GMGN.ai Token Scraper — Meme Coins & DeFi Data (`bovi/gmgn-scraper`) Actor

Scrape **real-time trending token data** from **GMGN.ai** across 5 chains (Solana, Ethereum, Base, BSC, Tron). Returns **40+ fields** per token: price, volume, market cap, liquidity, holder count, **smart-money signals**, and **risk flags** — honeypot, rug ratio, sniper count, bundler rate.

- **URL**: https://apify.com/bovi/gmgn-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** AI, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $16.59 / 1,000 token results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## GMGN.ai Token Scraper — Meme Coins & DeFi Data

Scrape **real-time trending meme-coin and DeFi token data** from [GMGN.ai](https://gmgn.ai) — the leading DeFi analytics platform tracking tokens on Solana, Ethereum, Base, BSC, and Tron.

Returns **40+ fields per token** including price, volume, market cap, liquidity, holder count, trading activity, and a full DeFi risk-signal suite: **honeypot detection, rug ratio, sniper count, bundler rate, smart-money flow**, and blue-chip ownership. No API key required. No login required. Pay per token result.

Faster alpha. Safer trades. Structured data your bots can actually use.

***

### What You Get — 40+ Fields Per Token

| Category | Fields |
|---|---|
| **Identity** | address, symbol, name, chain, rank |
| **Price** | price, price\_change\_pct\_1m/5m/1h/6h/24h, price\_change\_pct\_period |
| **Market** | volume, market\_cap, liquidity, total\_supply, initial\_liquidity |
| **Trading** | swaps, buys, sells |
| **Holders** | holder\_count, top\_10\_holder\_rate |
| **Risk** | is\_honeypot, rug\_ratio, sniper\_count, bundler\_rate, renounced\_mint, renounced\_freeze\_account, bluechip\_owner\_percentage, smart\_degen\_count, bot\_degen\_count |
| **Socials** | twitter\_username, website, telegram |
| **Timing** | open\_timestamp, created\_at (ISO UTC) |
| **Quality** | parse\_confidence, warnings |

***

### Why This GMGN Scraper Beats Manual Monitoring

GMGN's web UI shows you trending tokens — but you can't pipe that data into a trading bot, a risk screener, or an analytics dashboard without an API. This actor gives you exactly that: structured JSON output for every token on GMGN's trending lists, automatically, on your schedule.

- **5 chains in one run**: Solana, Ethereum, Base, BSC, Tron — no separate scrapers
- **5 time windows**: 1m, 5m, 1h, 6h, 24h — catch both micro-momentum and daily trends
- **Risk signals baked in**: honeypot + rug ratio + sniper count in every record — no manual filtering
- **`parse_confidence` on every record**: machine-readable quality signal so your pipeline knows when the source has changed

***

### How to Use

#### Trending mode (default)

```json
{
  "mode": "trending",
  "chains": ["sol", "eth"],
  "periods": ["1h", "24h"],
  "orderby": "swaps",
  "filters": ["not_honeypot"]
}
```

- `chains`: `sol`, `eth`, `base`, `bsc`, `tron`
- `periods`: `1m`, `5m`, `1h`, `6h`, `24h`
- `orderby`: `swaps`, `volume`, `marketcap`, `holder_count`, `smartmoney`, `liquidity`, `open_timestamp`
- `filters`: optional safety pre-filters — `not_honeypot`, `renounced`, `verified`

Each chain × period combination returns up to 100 tokens.

#### Token detail mode

```json
{
  "mode": "token_detail",
  "chains": ["sol"],
  "tokenAddresses": [
    "So11111111111111111111111111111111111111112",
    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
  ]
}
```

Fetches metadata (decimals, circulating supply, pool address, creation time) for specific token addresses.

***

### Use Cases

#### Trading bot alpha feed

Pull `1m` and `5m` trending tokens sorted by `swaps` to detect early momentum before price moves. Filter `is_honeypot=false` server-side and feed directly into your entry logic.

#### DeFi risk screening

Before buying any token, verify `rug_ratio`, `sniper_count`, and `bundler_rate`. Tokens with `renounced_mint=true` and `bluechip_owner_percentage > 0.05` signal safer projects.

#### Cross-chain market analytics

Compare trending volume across Solana vs Ethereum vs Base simultaneously. Identify which chains show early capital rotation.

#### AI agent data layer

Works as a structured data source for AI agents via the Apify MCP server. Your LLM agent can pull fresh token data on demand without custom API integration.

#### Smart-money tracking

Filter by `smart_degen_count > 0` to find tokens attracting attention from GMGN's tracked smart wallets before they trend in mainstream feeds.

***

### Pricing

**$2.00 per 1,000 token results** (Pay Per Event — `token-result`).

| Run scope | Tokens | Cost |
|---|---|---|
| Single chain × single period (e.g. sol/1h) | ~100 | $0.20 |
| 2 chains × 2 periods | ~400 | $0.80 |
| Full sweep (5 chains × 5 periods) | ~2,500 | $5.00 |

You only pay for tokens successfully returned. Failed fetches are not charged.

***

### Technical Notes

#### Access handling

Uses lightweight HTTP requests that pass Cloudflare's checks without a browser or any API key (verified live 2026-06-04).

#### Parse confidence

Every record includes `parse_confidence` (0.0–1.0). Values below 0.8 indicate the API response structure may have changed — your downstream pipeline can alert on this without manual checks.

#### Proxy

Default: Apify Residential (buyer-paid). Datacenter IPs may receive higher Cloudflare bot scores — residential is the safe default for cloud runs.

#### No API key required

GMGN's public trending endpoints are accessible without authentication. This actor requires no GMGN account, no API subscription.

***

*Not affiliated with GMGN.ai. Data is retrieved from publicly accessible GMGN.ai endpoints.*

### Integrations

Built for DeFi traders and on-chain analysts feeding meme-coin risk signals and smart-money flows into trading bots — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### What it does

GMGN.ai Token Scraper — Meme Coins & DeFi Data is a data-collection tool for the ai, marketing, and developer tools category. The inputs let you set the scope and preferences for a run, while the results provide organized records that are easier to review and use.

### Input

Provide the values that define the scope and preferences for the run. Review each option before starting so the resulting dataset matches the information you want to analyze or reuse.

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| chains | array | Blockchain(s) to scrape. Supported: sol (Solana), eth (Ethereum), base (Base), bsc (BNB Chain), tron (Tron). Default: \['sol']. Multiple chains produce independent result sets. | \["sol"] |
| filters | array | Optional GMGN API filters to apply. Common values: not\_honeypot, renounced, verified. Leave empty for unfiltered results (includes risky tokens). | — |
| includeTokenDetail | boolean | When enabled in trending mode, makes an additional /api/v1/token\_info request per token to add decimals, circulating\_supply, biggest\_pool\_address fields. Slower and more requests, but richer data. | false |
| maxResults | integer | Maximum total records to push across all chains+periods. 0 = no limit (returns all). Each chain×period combination yields up to 100 tokens. | 0 |
| mode | string | trending — fetch top 100 tokens from GMGN rank/swaps (default). token\_detail — fetch metadata for specific token addresses you supply. | "trending" |
| orderby | string | Field to sort trending results by. swaps = most active trading. volume = highest USD volume. marketcap = largest market cap. holder\_count = most holders. smartmoney = smart-money trader flow. liquidity = most liquid. open\_timestamp = newest tokens. | "swaps" |
| periods | array | Time window(s) for trending mode. Options: 1m, 5m, 1h, 6h, 24h. Each period returns up to 100 tokens sorted by the orderby field. Multiple periods = independent result sets. | \["1h"] |
| proxyConfiguration | object | Apify proxy settings. Default residential proxy recommended for reliable access. The actor uses curl\_cffi Chrome impersonation to match a real Chrome TLS profile. Datacenter IPs may be less reliable; residential increases reliability. | {"useApifyProxy":true,"apifyProxyGroups":\["RESIDENTIAL"]} |
| tokenAddresses | array | List of token contract addresses to look up. Required when mode=token\_detail. Example for Solana: \['So11111111111111111111111111111111111111112'] | — |

### Output

A successful run produces a dataset of structured items collected according to your inputs. You can review the records, use them in analysis, or pass them to another part of your workflow. The exact fields depend on the source data and the options selected for the run.

### Usage

1. Open the actor page.
2. Fill in the input values and review the configuration.
3. Run the actor and wait for the collection to finish.
4. Download the results from the dataset and use the records in your preferred workflow.

# Actor input Schema

## `mode` (type: `string`):

trending — fetch top 100 tokens from GMGN rank/swaps (default). token\_detail — fetch metadata for specific token addresses you supply.

## `chains` (type: `array`):

Blockchain(s) to scrape. Supported: sol (Solana), eth (Ethereum), base (Base), bsc (BNB Chain), tron (Tron). Default: \['sol']. Multiple chains produce independent result sets.

## `periods` (type: `array`):

Time window(s) for trending mode. Options: 1m, 5m, 1h, 6h, 24h. Each period returns up to 100 tokens sorted by the orderby field. Multiple periods = independent result sets.

## `orderby` (type: `string`):

Field to sort trending results by. swaps = most active trading. volume = highest USD volume. marketcap = largest market cap. holder\_count = most holders. smartmoney = smart-money trader flow. liquidity = most liquid. open\_timestamp = newest tokens.

## `filters` (type: `array`):

Optional GMGN API filters to apply. Common values: not\_honeypot, renounced, verified. Leave empty for unfiltered results (includes risky tokens).

## `tokenAddresses` (type: `array`):

List of token contract addresses to look up. Required when mode=token\_detail. Example for Solana: \['So11111111111111111111111111111111111111112']

## `includeTokenDetail` (type: `boolean`):

When enabled in trending mode, makes an additional /api/v1/token\_info request per token to add decimals, circulating\_supply, biggest\_pool\_address fields. Slower and more requests, but richer data.

## `maxResults` (type: `integer`):

Maximum total records to push across all chains+periods. 0 = no limit (returns all). Each chain×period combination yields up to 100 tokens.

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

Apify proxy settings. Default residential proxy recommended for reliable access. The actor uses curl\_cffi Chrome impersonation to match a real Chrome TLS profile. Datacenter IPs may be less reliable; residential increases reliability.

## Actor input object example

```json
{
  "mode": "trending",
  "chains": [
    "sol"
  ],
  "periods": [
    "1h"
  ],
  "orderby": "swaps",
  "includeTokenDetail": false,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing Gmgn Scraper records (rank, symbol, name, chain, price, price\_change\_pct\_period, volume, market\_cap, holder\_count, is\_honeypot, rug\_ratio, parse\_confidence).

# 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 = {
    "mode": "trending",
    "chains": [
        "sol"
    ],
    "periods": [
        "1h"
    ],
    "orderby": "swaps",
    "includeTokenDetail": false,
    "maxResults": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/gmgn-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 = {
    "mode": "trending",
    "chains": ["sol"],
    "periods": ["1h"],
    "orderby": "swaps",
    "includeTokenDetail": False,
    "maxResults": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/gmgn-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 '{
  "mode": "trending",
  "chains": [
    "sol"
  ],
  "periods": [
    "1h"
  ],
  "orderby": "swaps",
  "includeTokenDetail": false,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/gmgn-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bovi/gmgn-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/4MlYRFTwV5iY7nGKH/builds/UlxheADHkYIStgjUI/openapi.json