# CoinMarketCap Community Scraper — API User & Posts (`webm/coinmarketcap-community`) Actor

Unofficial CoinMarketCap Community (Gravity) API: scrape an author's recent posts, a user's profile, or a coin's top trending posts. Fast HTTP endpoints, clean JSON, bring your own proxies

- **URL**: https://apify.com/webm/coinmarketcap-community.md
- **Developed by:** [George WebM](https://apify.com/webm) (community)
- **Categories:** Social media, Developer tools, News
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 post stats queries

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?

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

## CoinMarketCap Community (Gravity) Scraper — Posts, Profiles, Trending (Unofficial)

**Scrape CoinMarketCap Community (Gravity)** — author **posts**, user **profiles**,
and a coin's **top trending posts**. Run the actor with a small JSON input, get
clean, structured **JSON** back in the run's dataset (and `OUTPUT`), ready to store
in your own database or pipeline. Use Apify Proxy or your own (datacenter is fine).

One run fetches one thing, chosen by the `mode` field:

- **`post-stats`** — an author's recent posts (likes, comments, reposts,
  impressions, reactions, topics, sentiment…).
- **`profile-stats`** — a user profile (followers, following, bio, verification,
  numeric `guid`, mindshare…).
- **`top-posts`** — the top trending posts for any coin, ranked by trending score.

> ⚠️ **Unofficial.** This scraper is **not affiliated with, endorsed by, or
> sponsored by CoinMarketCap.** All trademarks are the property of their
> respective owners.

### Use cases

- **Crypto influencer / KOL tracking** — monitor what top CoinMarketCap Community
  accounts post and how their audience reacts.
- **Mindshare & sentiment** — pull follower counts, mindshare and post sentiment
  to track narratives around a coin.
- **Trending research** — grab the top posts for BTC, ETH, SOL or any coin to see
  what's driving attention right now.
- **Datasets & dashboards** — export the JSON into your own crawler pipeline,
  spreadsheet, database or BI dashboard.

### How to run it

Start the actor with an input JSON — from the Apify Console (**Input** tab),
the API, a schedule, or an integration (Make.com, n8n, Zapier…).

```json
{ "mode": "profile-stats", "handle": "goonrich" }
```

- **Async:** `POST /v2/acts/<actor>/runs` → the run finishes → read its **dataset**
  (one item) or `OUTPUT` record.
- **Synchronous:** `POST /v2/acts/<actor>/run-sync-get-dataset-items` waits for the
  run and returns the dataset items directly in the response — handy for
  Make.com / code that wants the data back in one call.

Results land in the run's **dataset — one row per result** (each post, or the
single profile). Every row includes `fetchedAt` (ISO / UTC).

### Modes & parameters

#### `mode: "post-stats"` — an author's recent posts

| Param | Required | Default | Notes |
|---|---|---|---|
| `handle` | yes | — | Gravity user handle — **same as the username** (the account's @name), with or without `@`. |
| `limit` | no | 10 | How many recent posts to return (max 100). |
| `proxyConfiguration` | no | — | Proxy (Apify Proxy or your own) — see below. |

```json
{ "mode": "post-stats", "handle": "goonrich", "limit": 25 }
```

Dataset: **one row per post** — each post as CoinMarketCap returns it, with its own
`owner` and `fetchedAt`.

#### `mode: "profile-stats"` — a user profile

| Param | Required | Notes |
|---|---|---|
| `handle` | yes | Gravity user handle — **same as the username** (the account's @name). |
| `proxyConfiguration` | no | Proxy (Apify Proxy or your own) — see below. |

```json
{ "mode": "profile-stats", "handle": "goonrich" }
```

Dataset: **one row** — the profile object (`followers`, `guid`, `mindshare`, …)
plus `fetchedAt`.

#### `mode: "top-posts"` — top trending posts for a coin

Already ranked — the top N are the first N.

| Param | Required | Default | Notes |
|---|---|---|---|
| `coin` | yes | — | The coin's **CMC slug** (e.g. `bitcoin`, `pepe`). |
| `limit` | no | 10 | How many top posts to return (max 100). |
| `proxyConfiguration` | no | — | Proxy (Apify Proxy or your own) — see below. |

**How to find the slug:** open the coin's page on CoinMarketCap and take the last
part of the URL. For example `https://coinmarketcap.com/currencies/pepe/` → the
slug is **`pepe`**. (Tickers like `BTC` are not used — many coins share a ticker;
the slug is unique.)

```json
{ "mode": "top-posts", "coin": "pepe", "limit": 20 }
```

Dataset: **one row per post**, each with its author (`owner`) and `fetchedAt`,
ranked (row 1 = top).

### Output

Results go to the run's **dataset — one row per result** (each post, or the single
profile). A short summary (`mode`, `count`) is stored in the run's **`OUTPUT`**
record. Fetch rows via the Apify API or `run-sync-get-dataset-items`, or export to
CSV / JSON / Excel from the dataset.

### Startup

Each run starts a fresh container, so it takes a few seconds to boot before it
answers. Runs are lightweight (no browser), so they're quick and cheap.

### Clean JSON, fields returned as-is

The scraper returns the CoinMarketCap fields **unchanged** — it does not rename or
drop useful data, so new fields keep coming through. It only selects the relevant
part of the response and adds `fetchedAt`. Easy to export to JSON, a dataset, or
straight into your own pipeline.

### Proxies

Configure proxies with the standard **Proxy** input — use **Apify Proxy** or your
**own** proxy URLs (datacenter is fine). The actor rotates across them and skips
dead ones. Optional: without a proxy, requests go out directly (fine for most
cases — the token is not IP-bound).

Apify Proxy:

```json
{ "mode": "top-posts", "coin": "pepe", "proxyConfiguration": { "useApifyProxy": true } }
```

Your own proxies:

```json
{ "proxyConfiguration": { "useApifyProxy": false, "proxyUrls": ["http://user:pass@host:port"] } }
```

### Pricing

Pay-per-event — you only pay per successful call:

| Mode | Price |
|---|---|
| `post-stats` | $4 / 1000 queries |
| `profile-stats` | $4 / 1000 queries |
| `top-posts` | $10 / 1000 posts returned |

**Free plan:** 20 runs per account to try it out; after that you'll get an
"upgrade" result. Paid plans are unlimited.

### Notes

- Data comes from a public social platform; profile data may be personal data —
  handle it in line with your local regulations (e.g. GDPR).
- Scraping may be restricted by CoinMarketCap's Terms of Service. Use responsibly
  and at your own risk.

***

This is an unofficial tool and is not affiliated with, endorsed by, or sponsored
by CoinMarketCap. All trademarks are the property of their respective owners.

# Actor input Schema

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

Choose one, then fill only the field in the matching section below.

## `handle` (type: `string`):

The account's @name (handle = username), e.g. goonrich (with or without @).

## `coin` (type: `string`):

The coin's CMC slug from its URL, e.g. coinmarketcap.com/currencies/pepe/ → pepe.

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

How many results to return (max 100). Ignored for profile-stats.

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

Proxy for outgoing requests — use Apify Proxy or your own proxy URLs. Optional: without a proxy, requests go out directly (fine for most cases — the WAF token is not IP-bound). The actor rotates across the configured proxies and skips dead ones.

## Actor input object example

```json
{
  "mode": "profile-stats",
  "handle": "goonrich",
  "coin": "bitcoin",
  "limit": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "handle": "goonrich",
    "coin": "bitcoin",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("webm/coinmarketcap-community").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 = {
    "handle": "goonrich",
    "coin": "bitcoin",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("webm/coinmarketcap-community").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 '{
  "handle": "goonrich",
  "coin": "bitcoin",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call webm/coinmarketcap-community --silent --output-dataset

```

## MCP server setup

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

```

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/P3eooKnoAGbkVkdNa/builds/CxCvqeNJaxBqEZBZd/openapi.json