# DeFiLlama Scraper - DeFi TVL, Yields, Fees & Protocols (`scrapesage/defillama-scraper`) Actor

Scrape DeFiLlama DeFi analytics: protocol TVL rankings & full profiles (per-chain TVL, funding rounds, GitHub/Twitter/website), yield-farming pools & APY, chain TVL, stablecoins, DEX volume and protocol fees & revenue. Monitoring mode for new launches. Export JSON, CSV, Excel.

- **URL**: https://apify.com/scrapesage/defillama-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Agents, 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 protocol / tvl records

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

## DeFiLlama Scraper — DeFi TVL, Yields, Fees, Stablecoins & Protocol Data

Extract **complete DeFi analytics from [DeFiLlama](https://defillama.com)** — the industry-standard source for on-chain data. Rank **protocols by TVL** with per-chain breakdowns, pull **yield-farming pools and APY**, compare **blockchain TVL**, track **stablecoin supply**, and measure **DEX trading volume** and **protocol fees & revenue**. Every protocol profile ships its **GitHub, Twitter, website, audits and funding rounds** (investors, amounts and valuations) — so the data doubles as deal-flow and project intelligence.

No login, no API key, no browser — fast JSON extraction straight from DeFiLlama's public API, with 99%+ reliability.

### Why this DeFiLlama scraper?

Most crypto scrapers stop at token prices. This actor pulls the **whole DeFi stack** — TVL, yields, chains, stablecoins, DEX volume and fees/revenue — and ships the **richest record in the category**, including the fundraising and contact fields nobody else surfaces.

| Data | Typical scrapers | This actor |
|---|---|---|
| Protocol TVL + 1h/24h/7d change | partial | ✅ |
| Per-chain TVL breakdown per protocol | ❌ | ✅ |
| Market cap + Mcap/TVL ratio | ❌ | ✅ |
| Funding rounds (investors, amount, valuation, round, date) | ❌ | ✅ |
| Protocol GitHub / Twitter / website / audits | ❌ | ✅ |
| Yield pools — base + reward APY, IL risk, ML prediction | ❌ | ✅ |
| Chain TVL + share-of-market ranking | ❌ | ✅ |
| Stablecoin circulating supply, peg, chain breakdown, growth | ❌ | ✅ |
| DEX trading volume (24h / 7d / 30d) | ❌ | ✅ |
| Protocol fees **and** revenue (merged) | ❌ | ✅ |
| Contact emails + lead score (from project website) | ❌ | ✅ opt-in |
| Monitor mode — only new launches / pools | ❌ | ✅ |

### Use cases

- **DeFi research & dashboards** — feed your own TVL/APY/volume dashboards, newsletters, and reports with structured, up-to-date numbers across 7,600+ protocols, 450+ chains and 16,000+ yield pools.
- **Yield hunting** — surface the highest-APY pools by chain, project, TVL floor and stablecoin-only, complete with reward breakdown, impermanent-loss risk and DeFiLlama's ML "predicted class".
- **Market & competitive intelligence** — track which protocols, chains and DEXs are gaining or losing TVL, volume and revenue, and benchmark a protocol against its category.
- **Deal flow & VC prospecting** — every protocol profile carries its **funding rounds** (lead and other investors, amounts, valuations) plus GitHub/Twitter/website — find recently-raised projects and the funds backing them.
- **Stablecoin monitoring** — watch circulating supply, peg mechanism, price and per-chain distribution, with day/week/month growth.
- **New-launch alerts** — run on a schedule with monitor mode to capture brand-new protocols and freshly-listed yield pools the moment they appear.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **DeFiLlama Scraper**, pick a **mode** (Protocols, Yield pools, Chains, Stablecoins, DEX volume, Fees & revenue, or Protocol detail), set any filters, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "protocols",
    "chainFilter": "Arbitrum",
    "categoryFilter": "Lending",
    "minTvlUsd": 1000000,
    "sortBy": "tvl",
    "enrichProtocolDetails": true,
    "enrichContacts": false,
    "maxResults": 200
}
```

- **mode** — `protocols` (TVL rankings), `protocolDetail` (deep dive on specific protocols), `yields` (pools & APY), `chains` (TVL per blockchain), `stablecoins`, `dexs` (DEX volume), `fees` (fees & revenue).
- **searchQueries** — protocol names/symbols to match (e.g. `Aave`, `Uniswap`, `Lido`); used by `protocols`, `protocolDetail`, `dexs`, `fees`.
- **protocolSlugs** — exact DeFiLlama slugs for `protocolDetail` (e.g. `aave-v3`, `uniswap-v3`, `lido`) — find them in the page URL `defillama.com/protocol/<slug>`.
- **startUrls** — paste DeFiLlama URLs (`/protocol/<slug>`, `/chain/<name>`, `/stablecoin/<name>`) to auto-route.
- **chainFilter / categoryFilter** — restrict to a chain (`Ethereum`, `Arbitrum`, `Solana`, `Base`…) or category (`Lending`, `Dexs`, `Liquid Staking`, `CDP`, `Bridge`…).
- **minTvlUsd / minApy / stablecoinPoolsOnly / yieldProject** — filters (TVL floor; yields-mode APY floor, stablecoin-only and per-project).
- **sortBy** — `tvl`, `apy`, `volume`, `fees`, or `change24h`; results are ranked highest-first before the cap.
- **enrichProtocolDetails** *(default false)* — open each protocol's full profile for per-chain TVL, market cap, GitHub/Twitter/website, audits, methodology, treasury and funding rounds (always on for `protocolDetail`).
- **enrichContacts** *(default false)* — crawl each protocol's own website (home + contact/about, max 3 pages) for contact emails and extra socials, with a 0–100 lead score.
- **maxResults** — cap per run. **monitorMode / monitorKey** — only output records not seen in previous runs (see below).

### Output

One record per entity, each tagged with a `type`. A `protocol` record (fields trimmed for brevity):

```json
{
    "type": "protocol",
    "name": "Lido",
    "slug": "lido",
    "symbol": "LDO",
    "category": "Liquid Staking",
    "primaryChain": "Multi-Chain",
    "chains": ["Ethereum", "Solana", "Moonbeam", "Moonriver"],
    "chainCount": 4,
    "tvl": 15802932401.54,
    "tvlChange1d": -1.35,
    "tvlChange7d": 7.45,
    "mcap": 246636422.14,
    "mcapTvlRatio": 0.016,
    "website": "https://lido.fi/",
    "twitter": "https://twitter.com/LidoFinance",
    "githubOrgs": ["lidofinance"],
    "topChainsByTvl": [{ "name": "Ethereum", "tvlUsd": 15799277679 }],
    "audits": 2,
    "openSource": true,
    "raises": [
        { "date": "2021-05-05T00:00:00.000Z", "amountUsd": 73000000, "round": "Series A", "leadInvestors": ["Paradigm"], "valuationUsd": null }
    ],
    "totalRaisedUsd": 167000000,
    "investors": ["Paradigm", "Coinbase Ventures", "Three Arrows Capital"],
    "tvlPeak": 39200000000,
    "defillamaUrl": "https://defillama.com/protocol/lido",
    "scrapedAt": "2026-06-17T16:31:31.900Z"
}
```

Other record types: **`yieldPool`** (total/base/reward APY, TVL, reward tokens, 1d/7d/30d APY change, IL risk, exposure, stablecoin flag, recent volume, ML `predictedClass`/`predictedProbability`), **`chain`** (TVL, share %, rank, token), **`stablecoin`** (circulating supply, peg type/mechanism, price, day/week/month growth, top chains), **`dexProtocol`** (24h/7d/30d/1y/all-time volume + change), and **`feeProtocol`** (fees **and** revenue over 24h/7d/30d/1y + change).

#### What to expect (field coverage)

DeFiLlama is community- and protocol-sourced, so a few fields are present only when published. A blank field means that datum doesn't exist for that record — nothing is dropped, so you always get the richest dataset available.

| Field group | Coverage |
|---|---|
| TVL, category, chains, change % | ✅ ~100% of protocols |
| Website / Twitter | ✅ ~90% |
| GitHub / audits / methodology | present when the team published them |
| Funding rounds (`raises`, investors) | present for VC-backed protocols |
| Market cap / Mcap-TVL ratio | present when the token has a known market cap |

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily to refresh a TVL/APY dashboard or to watch a chain, category or yield search for new entries.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (alert, CRM import, dashboard refresh) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/defillama-scraper').call({
    mode: 'yields',
    chainFilter: 'Arbitrum',
    minApy: 8,
    minTvlUsd: 1000000,
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} yield pools`);
```

#### Monitor mode (only new) + scheduling

Turn on **monitorMode** to remember everything seen in previous runs (in a named key-value store) and output **only newly-appearing** protocols, pools, chains or stablecoins. It's the clean way to catch **new DeFi launches and freshly-listed yield pools**. Monitor mode complements [Apify Schedules](https://docs.apify.com/platform/schedules) — the schedule starts the run, monitor mode filters it down to what's new — so there's no conflict between them. Use a distinct **monitorKey** per saved search (e.g. `arbitrum-lending`, `high-apy-stables`) so each tracks its own seen-set.

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new pools or protocols straight into a sheet or Slack.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds something new.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the highest-APY stablecoin pools on Base with at least $1M TVL" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **crypto & market-intelligence stack**:

- **[CoinGecko Crypto Scraper](https://apify.com/scrapesage/coingecko-crypto-scraper)** — coin prices, markets, NFTs, exchanges, categories & global data.
- **[Prediction Markets Scraper](https://apify.com/scrapesage/prediction-markets-scraper)** — Polymarket + Kalshi odds, volume, holders & cross-platform arbitrage.
- **[Yahoo Finance Scraper](https://apify.com/scrapesage/yahoo-finance-scraper)** — stocks, ETFs, crypto, FX, financial statements & analyst ratings.
- **[SEC EDGAR Scraper](https://apify.com/scrapesage/sec-edgar-scraper)** — company filings, XBRL financials & insider transactions.
- **[Sports Betting Odds Scraper](https://apify.com/scrapesage/sports-betting-odds-scraper)** — multi-book odds, no-vig fair lines & arbitrage.
- **[FEC Campaign Finance Scraper](https://apify.com/scrapesage/fec-campaign-finance-scraper)** — donors, candidates, committees & lobbying.
- **[Google Trends Scraper](https://apify.com/scrapesage/google-trends-scraper)** — search-demand interest, related queries & trending now.
- **[GitHub Scraper](https://apify.com/scrapesage/github-scraper)** — repos, developers, activity & developer leads.

### Tips

- **Pick the right mode for a clean table** — each mode produces one dense record type. Use the dataset's view selector (Protocols / Yields / Chains / Stablecoins / DEX / Fees) to switch column layouts.
- **Enrichment is opt-in** — `enrichProtocolDetails` adds one request per protocol for per-chain TVL, audits and funding rounds; leave it off for fast, cheap TVL leaderboards.
- **Yield filters compose** — combine `chainFilter`, `yieldProject`, `minApy`, `minTvlUsd` and `stablecoinPoolsOnly` to pinpoint exactly the pools you want.
- **Funding intelligence** — run `protocols` (or `protocolDetail`) with `enrichProtocolDetails` to capture `raises`, `investors` and `totalRaisedUsd` for deal-flow research.
- **Recurring monitoring** — combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to track only new launches.

### FAQ

**Does it need a DeFiLlama API key?** No. This actor uses DeFiLlama's free public API — no key, no login, no browser. (The paid Pro-only endpoints are not required.)

**Which chains and protocols are covered?** All of them — DeFiLlama tracks 7,600+ protocols across 450+ chains, plus 16,000+ yield pools, all stablecoins, every DEX and every fee-earning protocol it indexes.

**Where do the funding rounds come from?** From DeFiLlama's own protocol profiles, which list raise date, round, amount, valuation and investors for VC-backed projects. They're included in the enriched protocol record.

**Where do contact emails come from?** Never from DeFiLlama. With `enrichContacts` on, the actor visits the protocol's own public website and extracts publicly listed contact emails and socials — the same thing a human visitor would see.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new DeFi launches automatically?** Turn on `monitorMode`, set a `monitorKey`, and create a [Schedule](https://docs.apify.com/platform/schedules) — each run outputs only protocols/pools that weren't seen before. Add a [webhook](https://docs.apify.com/platform/integrations/webhooks) to push them to Slack or a CRM.

**A field is null — why?** Some protocols don't publish a market cap, GitHub, audits or funding. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

**Is scraping DeFiLlama legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws and DeFiLlama's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

protocols = DeFi protocols ranked by TVL (+ optional full profile). protocolDetail = deep dive on specific protocols. yields = yield-farming pools & APY. chains = TVL per blockchain. stablecoins = stablecoin supply. dexs = DEX trading volume. fees = protocol fees & revenue.

## `searchQueries` (type: `array`):

Protocol names or symbols to match (e.g. "Aave", "Uniswap", "Lido"). Used by the protocols / protocolDetail / dexs / fees modes to filter to specific protocols. Matched against protocol name, slug and symbol.

## `protocolSlugs` (type: `array`):

Exact DeFiLlama protocol slugs for protocolDetail mode, e.g. "aave-v3", "uniswap-v3", "lido". Find a slug in the protocol page URL: defillama.com/protocol/<slug>. Faster and more precise than search queries.

## `startUrls` (type: `array`):

Paste DeFiLlama URLs to auto-route: defillama.com/protocol/<slug>, /chain/<name>, /stablecoin/<name>. Protocol URLs feed protocolDetail; the type is detected automatically.

## `chainFilter` (type: `string`):

Only include protocols / yield pools deployed on this chain, e.g. "Ethereum", "Arbitrum", "Solana", "Base". Leave empty for all chains. Applies to protocols, yields, dexs and fees modes.

## `categoryFilter` (type: `string`):

Only include protocols in this category, e.g. "Lending", "Dexs", "Liquid Staking", "Yield", "CDP", "Bridge", "Derivatives". Leave empty for all categories. Applies to protocols / fees modes.

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

Only include protocols / yield pools / chains with at least this much total value locked, in USD. Use to skip dust. 0 = no minimum.

## `minApy` (type: `integer`):

yields mode only: only include pools with a total APY at or above this percentage (e.g. 5 = 5%). 0 = no minimum.

## `stablecoinPoolsOnly` (type: `boolean`):

yields mode only: keep only pools made up of stablecoins (lower impermanent-loss risk).

## `yieldProject` (type: `string`):

yields mode only: only include pools from this project, e.g. "aave-v3", "lido", "curve-dex", "compound-v3". Leave empty for all projects.

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

Ranking field. protocols/chains: tvl. yields: apy or tvl. dexs/fees: volume / fees. Records are ranked highest-first before the result cap is applied.

## `enrichProtocolDetails` (type: `boolean`):

protocols mode: open each protocol's full profile for per-chain TVL, market cap, GitHub/Twitter/website, audits, methodology, treasury and funding rounds (investors, amounts, valuations). One extra request per protocol. Always on for protocolDetail.

## `enrichContacts` (type: `boolean`):

Crawl each protocol's own website (home + contact/about, max 3 pages) for contact emails and extra social links, and compute a 0-100 lead score. Requires a protocol website (most have one). Adds a few requests per protocol.

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

Maximum number of records to output for this run. Records are ranked by the chosen sort field first, so you keep the top N.

## `monitorMode` (type: `boolean`):

Remember records seen in previous runs (in a named key-value store) and output ONLY newly-appearing protocols / pools / chains / stablecoins. Ideal on a schedule to catch new DeFi launches and new yield pools. Works alongside Apify Schedules.

## `monitorKey` (type: `string`):

Label that groups a monitor watchlist across runs. Use a distinct key per saved search (e.g. "arbitrum-lending", "high-apy-stables") so each tracks its own seen-set.

## `deduplicateResults` (type: `boolean`):

Drop duplicate records within a single run (by stable id). Recommended.

## `maxConcurrency` (type: `integer`):

Parallel detail/enrichment requests. Lower this if you hit rate limits.

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

Proxy settings. DeFiLlama's API is public; Apify datacenter proxy (default) works well. The actor rotates the proxy session and retries on rate limits.

## Actor input object example

```json
{
  "mode": "protocols",
  "searchQueries": [
    "Aave",
    "Uniswap",
    "Lido"
  ],
  "minTvlUsd": 0,
  "minApy": 0,
  "stablecoinPoolsOnly": false,
  "sortBy": "tvl",
  "enrichProtocolDetails": false,
  "enrichContacts": false,
  "maxResults": 100,
  "monitorMode": false,
  "monitorKey": "default",
  "deduplicateResults": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records as JSON items in the default dataset.

# 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 = {
    "searchQueries": [
        "Aave",
        "Uniswap",
        "Lido"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/defillama-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 = {
    "searchQueries": [
        "Aave",
        "Uniswap",
        "Lido",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/defillama-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 '{
  "searchQueries": [
    "Aave",
    "Uniswap",
    "Lido"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/defillama-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapesage/defillama-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/03cuo6QDfnmYCC6KH/builds/D5vUcTrJLn8Y0VooV/openapi.json