# DappRadar Scraper (`crawlerbros/dappradar-scraper`) Actor

Scrape DappRadar.com - dapp rankings, blockchain rankings, token rankings, and dapp profile pages across 150+ chains and 9 categories (DeFi, Games, Gambling, NFT, Marketplaces, Social, Exchanges). Search dapps/chains/tokens by keyword. No auth, no proxy required.

- **URL**: https://apify.com/crawlerbros/dappradar-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## DappRadar Scraper

Scrape [DappRadar.com](https://dappradar.com) — the web3 industry's dapp rankings platform covering 15,000+ decentralized applications across 150+ blockchains. Get dapp rankings (market cap, volume, TVL, active wallets), blockchain rankings, curated token-category rankings, site search, and full dapp profile pages (description, categories, chains, socials, KPIs). HTTP-only against the public site — no auth, no login, no proxy required in normal operation.

### What this actor does

- **Six modes:** `dapps`, `chains`, `tokens`, `search`, `dappDetail`, `narratives`
- **150+ chains** and **9 dapp categories** as filterable enums (DeFi, Games, Gambling, Exchanges, Collectibles, Marketplaces, Social, Other, High Risk)
- **7 curated token categories** (AI Coins, DePIN, Gaming, Meme Coins, New Tokens, Price Predictions, RWA)
- **3 ranking periods** (24h / 7d / 30d) and **4 display currencies** (USD, EUR, BTC, ETH)
- **Full dapp profiles** — description, categories, chains, social links, and KPI stats (balance, volume, transactions, UAW, TVL)
- **Auto-pagination** — `dapps` and `tokens` rankings automatically walk DappRadar's `/page/2`, `/page/3`... pagination until `maxItems` is reached or DappRadar runs out of rows (up to ~3,000+ dapps and however many tokens a category holds, not just the first ~50)
- **Auto-escalation** — if DappRadar ever returns HTTP 403/429, the actor automatically retries once through the free Apify AUTO datacenter proxy
- **Empty fields are omitted** — every record only contains fields that were actually populated with real data

### Modes

| Mode | What it fetches | Source page |
|---|---|---|
| `dapps` (default) | Dapp rankings, optionally filtered by chain/category/period | `dappradar.com/rankings` |
| `chains` | Blockchain rankings by market cap, price, volume, dapp count | `dappradar.com/rankings/chains` |
| `tokens` | Token rankings within a curated category | `dappradar.com/rankings/tokens/<category>` |
| `search` | Site-wide search across dapps, chains, and tokens | `dappradar.com/?s=<query>` |
| `dappDetail` | Full profile page for one or more specific dapps | `dappradar.com/dapp/<slug>` |
| `narratives` | Curated trending-narrative rankings mixing dapps + tokens (AI, DeFi, Gambling, Gaming, Meme, RWA, Sweepstakes) | `dappradar.com/narratives/<narrative>` |

### Output fields

Fields vary by `recordType` — only populated fields are emitted (no nulls/empty strings/empty arrays).

**`dappRanking` (mode=dapps):** `rank`, `name`, `symbol`, `dappSlug`, `dappRadarUrl`, `iconUrl`, `chains[]`, `category`, `marketCapUsd`, `priceUsd`, `change24hPct`, `volume24hUsd`, `uaw`, `tvlUsd`, `currency`, `recordType`, `scrapedAt`. The `gambling` category renders a different metric table on DappRadar itself (Balance / Deposits(24h) instead of Market Cap / Price / Volume(24h)) — for that category, records carry `balanceUsd` and `depositsUsd` instead of `marketCapUsd`/`priceUsd`/`volume24hUsd` (fields are matched to DappRadar's own column headers, not a fixed position, so this is always correct even if DappRadar changes a category's columns).

**`chainRanking` (mode=chains):** `rank`, `name`, `symbol`, `chainSlug`, `dappRadarUrl`, `iconUrl`, `priceUsd`, `change24hPct`, `marketCapUsd`, `volume24hUsd`, `dappsCount`, `currency`, `recordType`, `scrapedAt`

**`tokenRanking` (mode=tokens):** `rank`, `name`, `symbol`, `tokenSlug`, `dappRadarUrl`, `iconUrl`, `tokenCategory`, `priceUsd`, `change24hPct`, `change7dPct`, `marketCapUsd`, `volume24hUsd`, `currency`, `recordType`, `scrapedAt`

Despite their `Usd`-suffixed names (kept for backward compatibility), the `marketCapUsd`/`priceUsd`/`volume24hUsd`/`tvlUsd` figures are denominated in whatever `currency` you requested — the `currency` field on every ranking record tells you which one (`USD`/`EUR`/`BTC`/`ETH`). `dappDetail` KPI figures are always USD; DappRadar's dapp-profile pages don't honor the `currency` parameter.

**`searchResult` (mode=search):** `name`, `entityType` (`dapp`/`chain`/`token`), `slug`, `description`, `imageUrl`, `updatedDate`, `dappRadarUrl`, `recordType`, `scrapedAt`

**`dappDetail` (mode=dappDetail):** `dappSlug`, `dappRadarUrl`, `openDappUrl`, `name`, `symbol`, `iconUrl`, `categories[]`, `primaryCategory`, `categoryRank`, `chains[]`, `chainsCount`, `rankLabel`, `description`, `socialLinks[]`, `websiteUrl`, `twitterUrl`, `discordUrl`, `telegramUrl`, `githubUrl`, `redditUrl`, `youtubeUrl`, `instagramUrl`, `mediumUrl`, `facebookUrl`, `linkedinUrl`, `tiktokUrl`, `balanceUsd`, `volume24hUsd`, `depositsUsd`, `transactions24h`, `uaw24h`, `tvlUsd`, `marketCapUsd`, `priceUsd`, `similarDapps[]` (DappRadar's own "related dapps" recommendations — each with `dappSlug`, `name`, `dappRadarUrl`, `category`, `chains[]`), `recordType`, `scrapedAt`. Gambling-category dapp profiles (e.g. `stake-com`) render a different KPI set on DappRadar itself (On-chain Balance / Deposits(24h) / Deposit Txs(24h) / Depositors(24h)) — those map to `balanceUsd`/`depositsUsd`/`transactions24h`/`uaw24h` respectively, matched by DappRadar's own tile labels rather than a fixed position.

**`narrativeRanking` (mode=narratives):** same fields as `dappRanking` above (`rank`, `name`, `symbol`, `dappSlug`, `dappRadarUrl`, `iconUrl`, `chains[]`, `marketCapUsd`, `priceUsd`, `change24hPct`, `volume24hUsd`, `volumeSharePct`, `uaw`, `tvlUsd`), plus `narrative` (the requested category) and `currency`. Narrative pages rank a curated mix of dapps and plain tokens together by real-time market cap/volume — DappRadar links every row (dapp or token) through the same `/dapp/<slug>` profile URL, so `dappSlug`/`dappRadarUrl` always resolve. `volumeSharePct` is that entity's share of the narrative's total 24h volume. The `sweepstakes` narrative instead surfaces `tvlUsd`/`uaw` (TVL and active-player count) in place of market/price/volume fields, matching its own "Prize game" table columns on DappRadar.

`openDappUrl` is the dapp's own product/website URL (DappRadar's "Open Dapp" button). `categoryRank` is the dapp's numeric rank within its own primary category (DappRadar's "Rank in Category" profile stat), distinct from `rankLabel`/`rank` which reflect its position in the overall/filtered rankings view being scraped. `chainsCount` is the total number of chains DappRadar lists the dapp as deployed on (from its profile sidebar), which can exceed the number of icons rendered in `chains[]` for dapps live on many chains. `socialLinks[]` is the raw list of every social/website URL DappRadar lists for the dapp (merged from both the icon row and the "Resources" sidebar, deduplicated); the individual `<platform>Url` fields (`websiteUrl`, `twitterUrl`, etc.) are the same URLs broken out by platform for direct programmatic access — only the platforms a dapp actually lists are present. `websiteUrl` is sourced from whichever of the icon row or Resources sidebar DappRadar renders it in (the icon row doesn't always include a Website icon, but the Resources sidebar reliably lists it as "Official Website" when the dapp has a site).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `dapps` | `dapps` / `chains` / `tokens` / `search` / `dappDetail` / `narratives` |
| `chain` | select | – (all) | Restrict dapp rankings to one of 150+ chains (mode=dapps) |
| `category` | select | – (all) | Restrict dapp rankings to one of 9 categories (mode=dapps) |
| `period` | select | `24h` | Ranking window: `24h` / `7d` / `30d` (mode=dapps) |
| `includeInactive` | boolean | `false` | Include dapps with no recently recorded activity — DappRadar's rankings show ~3,000 active dapps by default; enabling this pulls the full 14,000+-dapp catalog (mode=dapps) |
| `tokenCategory` | select | `meme-coins` | Required curated category (mode=tokens) |
| `currency` | select | `USD` | Display currency: `USD` / `EUR` / `BTC` / `ETH` |
| `searchQuery` | string | `uniswap` | Free-text query (mode=search) |
| `entityType` | select | – (all) | Keep only `dapp` / `chain` / `token` search results |
| `dappSlugs` | array | `["uniswap"]` | Dapp slugs or full URLs (mode=dappDetail) |
| `narrative` | select | `ai` | Curated narrative: `ai` / `defi` / `gambling` / `gaming` / `meme` / `rwa` / `sweepstakes` (mode=narratives) |
| `minMarketCapUsd` | int | – | Drop records below this market cap (records without the field pass through) |
| `minVolume24hUsd` | int | – | Drop records below this 24h volume |
| `minTvlUsd` | int | – | Drop records below this TVL |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000). `dapps`/`tokens` auto-paginate to reach this cap; `narratives` is a single ~60-row view |
| `proxyConfiguration` | proxy | AUTO | Not used unless DappRadar returns a block (403/429) mid-run |

#### Example: top DeFi dapps on Ethereum this week

```json
{
  "mode": "dapps",
  "chain": "ethereum",
  "category": "defi",
  "period": "7d",
  "maxItems": 30
}
```

#### Example: blockchain rankings

```json
{
  "mode": "chains",
  "maxItems": 50
}
```

#### Example: meme-coin token rankings

```json
{
  "mode": "tokens",
  "tokenCategory": "meme-coins",
  "maxItems": 50
}
```

#### Example: search

```json
{
  "mode": "search",
  "searchQuery": "pancakeswap",
  "entityType": "dapp"
}
```

#### Example: dapp profile lookup

```json
{
  "mode": "dappDetail",
  "dappSlugs": ["uniswap", "pancakeswap-amm-v3", "opensea"]
}
```

### Use cases

- **Web3 market research** — track top dapps/chains/tokens by volume, TVL, and active users
- **Competitive intelligence** — monitor a category (DeFi, Games, NFT Marketplaces) across chains
- **Portfolio/watchlist tools** — pull structured metrics for a curated list of dapps
- **Trend analysis** — compare 24h/7d/30d rankings to spot momentum shifts
- **Directory/aggregator sites** — build a searchable dapp catalog with descriptions and social links

### FAQ

**Do I need cookies, an API key, or a proxy?**  No. DappRadar serves fully server-rendered HTML with no login wall. The actor only engages the free Apify AUTO proxy automatically if it ever hits a block.

**Why do some records have fewer fields than others?**  DappRadar itself doesn't always have every metric for every dapp/chain/token (e.g. many dapps show "—" for TVL). The actor never fabricates missing data — it simply omits the field.

**How many rows does a rankings page return?**  DappRadar's `/rankings` and `/rankings/tokens/<category>` views render 50 rows per page and the actor automatically walks additional pages (`/page/2`, `/page/3`, ...) until it reaches `maxItems` or DappRadar has no more rows for that filter combination (dapp rankings can run to 3,000+ rows across ~60 pages; token categories are usually 1-2 pages). `/rankings/chains` renders all tracked chains (~150) on a single page — no pagination needed. `maxItems` caps how many the actor pushes; it cannot exceed what DappRadar's HTML actually contains.

**What does `entityType` mean in search results?**  DappRadar's search mixes dapps, chains, and tokens in one result list. `entityType` is derived from the result's URL pattern (`/dapp/`, `/rankings/protocol/`, `/token/`) so you can filter to just one kind.

**Can I combine `chain` and `category` filters?**  Yes. Setting both together automatically routes the request through DappRadar's `/rankings/protocol/<chain>/category/<category>` view, which is the one DappRadar page that applies both filters as a true intersection (its `/rankings/category/<cat>?chain=...` query-param combo, by contrast, ignores the chain param server-side). `chain` alone or `category` alone use their respective single-filter views as before.

**Why USD by default?**  DappRadar's default currency is USD; the `currency` input maps to DappRadar's own `cur` query parameter (EUR/BTC/ETH also supported).

**How fresh is the data?**  DappRadar's rankings update continuously (near-real-time market data); this actor always fetches live pages, so results reflect whatever DappRadar shows at request time.

**Why does `dapps` mode default to ~3,000 results out of the "15,000+ dapps" DappRadar advertises?**  DappRadar's default `/rankings` view only lists dapps with recently recorded on-chain activity. Set `includeInactive` to `true` to pull DappRadar's full tracked catalog (14,000+ dapps), including ones with no recent volume/users — those rows will simply have fewer populated metric fields (DappRadar itself has nothing to report for them).

# Actor input Schema

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

What to fetch.

## `chain` (type: `string`):

Restrict dapp rankings to a single blockchain. Leave empty for all chains.

## `category` (type: `string`):

Restrict dapp rankings to a single category.

## `period` (type: `string`):

Time window the ranking metrics are computed over.

## `includeInactive` (type: `boolean`):

By default DappRadar's rankings only list dapps with recently recorded activity (~3,000). Turn this on to include the full catalog of 14,000+ tracked dapps (DappRadar's `?all=1` view), including ones with no recent volume/users.

## `tokenCategory` (type: `string`):

Curated token category to rank (required for mode=tokens).

## `narrative` (type: `string`):

Curated trending-narrative ranking to fetch (required for mode=narratives). Mixes dapps and plain tokens ranked together, e.g. `defi` includes both DeFi dapps and DeFi-related tokens.

## `currency` (type: `string`):

Currency used for price/market-cap/volume figures.

## `searchQuery` (type: `string`):

Free-text query matched against dapp, chain, and token names.

## `entityType` (type: `string`):

Only keep search results of this type.

## `dappSlugs` (type: `array`):

DappRadar dapp slugs or full dapp URLs, e.g. `uniswap` or `https://dappradar.com/dapp/uniswap`.

## `minMarketCapUsd` (type: `integer`):

Drop records with a lower market cap than this (records missing market cap pass through).

## `minVolume24hUsd` (type: `integer`):

Drop records with lower 24h volume than this (records missing volume pass through).

## `minTvlUsd` (type: `integer`):

Drop records with lower total value locked than this (records missing TVL pass through).

## `maxItems` (type: `integer`):

Hard cap on emitted records. Dapp/token rankings auto-paginate (50 rows/page) up to this cap; chain rankings are a single ~150-row view; narrative rankings are a single ~60-row view.

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

Not required in normal operation — DappRadar serves plain HTML without a proxy. Kept as a fallback: the actor automatically engages the free Apify AUTO datacenter proxy only if it gets blocked (HTTP 403/429) mid-run.

## Actor input object example

```json
{
  "mode": "dapps",
  "chain": "",
  "category": "",
  "period": "24h",
  "includeInactive": false,
  "tokenCategory": "meme-coins",
  "narrative": "ai",
  "currency": "USD",
  "searchQuery": "uniswap",
  "entityType": "",
  "dappSlugs": [
    "uniswap"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped DappRadar records.

# 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": "dapps",
    "chain": "",
    "category": "",
    "period": "24h",
    "includeInactive": false,
    "tokenCategory": "meme-coins",
    "narrative": "ai",
    "currency": "USD",
    "searchQuery": "uniswap",
    "entityType": "",
    "dappSlugs": [
        "uniswap"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/dappradar-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": "dapps",
    "chain": "",
    "category": "",
    "period": "24h",
    "includeInactive": False,
    "tokenCategory": "meme-coins",
    "narrative": "ai",
    "currency": "USD",
    "searchQuery": "uniswap",
    "entityType": "",
    "dappSlugs": ["uniswap"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/dappradar-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": "dapps",
  "chain": "",
  "category": "",
  "period": "24h",
  "includeInactive": false,
  "tokenCategory": "meme-coins",
  "narrative": "ai",
  "currency": "USD",
  "searchQuery": "uniswap",
  "entityType": "",
  "dappSlugs": [
    "uniswap"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/dappradar-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/dappradar-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/69VN3Jb9emEgzD8Sr/builds/aWNtCPVmgjKQprtW3/openapi.json