# Crypto Data API - Messari and Blockworks Asset Metrics (`nabeelbaghoor/crypto-asset-data-api`) Actor

Crypto data API from Blockworks and Messari: 40k+ assets, prices, market caps, supply, volatility, protocol revenue, DEX, lending, stablecoins, ETFs, funding rounds, token unlocks, mindshare, news, research and verified intel. Any table or timeseries in one dataset. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/crypto-asset-data-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 data table row returneds

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?

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

## Crypto Data API - Messari and Blockworks Asset Metrics

Export crypto asset, market, onchain, fundraising, token unlock, news, research and intel data from the Blockworks API (which now also serves the Messari data) into an Apify dataset with your own Blockworks API key: 40k+ assets, any of 46 data tables and 61 timeseries models, and analyst-verified developments.

This actor wraps the Blockworks REST API at api.blockworks.com, the standardized interface behind the Messari and Blockworks research platforms. It turns a table name and filters, a list of slugs or symbols, or a timeseries model and series keys into clean, deduplicated rows you can download as JSON, CSV or Excel, schedule on a timer, or feed into trading models, research dashboards, spreadsheets, data warehouses and AI agents. Bring your own API key.

### What it does

- **Crypto screener over any data table**: assets (name, symbol, sectors, stablecoin and wrapped flags, contracts, circulating market cap and rank), blockchains, markets, perpetual markets, funding rounds, investors, funds and fund managers, acquisitions, the news feed, research reports, stablecoins, tokenized equities and commodities, ETFs, digital asset treasury companies, spot and perp DEXs, lending protocols and markets, vaults, launchpads and token transparency filings. Filter with the table's documented operators, sort and page through everything.
- **Lookup by slug, symbol or ID**: one row per identifier, such as `bitcoin`, `ETH` or a UUID.
- **Timeseries history**: price candles (open, high, low, close, volume), market cap and dominance, supply, realized volatility, Sharpe ratio, protocol revenue, DEX and lending metrics, stablecoin supply by chain, issuer and currency, ETF flows, treasury holdings, token unlock schedules, sector market data and fundraising, social mindshare and sentiment, and trending topics, at 5 minute to monthly granularity.
- **Slugs resolved for you**: asset, blockchain and market keys given as a slug or symbol are resolved to the primary key first, because the timeseries routes return an empty series for a slug.
- **Monitoring intel**: analyst-verified developments and events across 1,000+ assets and 700+ sources, filtered by asset, category, importance, verification, governance and time, plus the intel taxonomy.
- **Model catalogs**: every table with its columns and filters, and every timeseries model with its granularities and access tier, or only the models your key can query.
- **Pay only for results**: a request the provider has nothing for becomes a free row that says why, never a charge.

### Input

| Field | Used by | What it does |
| --- | --- | --- |
| `mode` | all | `tabular` (screener, default), `tabularRow` (lookup), `timeseries`, `developments`, `events`, `categories`, `tabularCatalog` or `timeseriesCatalog` |
| `tabularModel` | screener, lookup | The data table, such as `assets`, `funding-rounds`, `news-feed` or `stablecoin-products` |
| `filters` | screener | JSON object of documented field plus operator names: `{"circulatingMarketcapRankLte": 100, "sectorIsOneOf": ["DeFi"]}`. Undocumented names are dropped with a warning |
| `sortBy`, `sortDirection` | screener | A sortable field of the table and the direction |
| `selections` | screener, lookup, timeseries | Columns or metrics to return, such as `close` and `volume` |
| `identifiers` | lookup | Keys, slugs or symbols, one per line |
| `timeseriesModel` | timeseries | Such as `asset-price`, `asset-marketcap`, `token-unlocks`, `protocol-revenue`, `sector-marketdata` |
| `granularity` | timeseries | `5m`, `1h`, `6h`, `1d` (default), `1w` or `1n` (month); each model supports a subset |
| `seriesKeys` | timeseries | Asset slugs, symbols or IDs, sector names, or IDs from the matching table; up to 20 per call, batched automatically |
| `timeframe` | timeseries | `30d` (default), `ytd`, `52w`, `365d`, `2025`, `2025-06` |
| `startDate`, `endDate` | timeseries, developments, events | `YYYY-MM-DD`, RFC3339 or unix seconds; replaces the timeframe |
| `assetIds`, `intelCategories`, `intelSubcategories`, `minimumImportance`, `verifiedOnly`, `actionableOnly`, `governanceOnly`, `preTgeOnly`, `assetSectors`, `assetSubsectors`, `eventIds`, `search` | developments, events | Monitoring filters |
| `catalogScope` | catalogs | All models, published models, or only those your key can query |
| `maxResults` | all | Row cap for the whole run (default 200) |
| `requestsPerMinute` | all | Pacing |
| `apiKey` | all | Your Blockworks API key, stored as a secret |

### How to get an API key

Create a key at app.blockworks.com/account/api (the same key covers the Data API, Monitoring and the MCP server; existing Messari API keys keep working). Most data tables need a paid Blockworks plan (Lite, Pro or Enterprise), and some datasets are sold separately; the catalog modes with the "Models my key can query" scope show exactly what your key reaches. Paste the key into the API key field or set the `DATA_API_KEY` environment secret. A run without a key ends cleanly with a message asking for one, before any request is sent.

### Example output

```json
{
  "mode": "timeseries",
  "modeLabel": "Timeseries points",
  "recordType": "timeseriesPoint",
  "model": "asset-price",
  "identifier": "bitcoin,ethereum",
  "found": true,
  "id": "1e31218a-e44e-4285-820c-8282ee222035|1788998400",
  "name": "Bitcoin",
  "slug": "bitcoin",
  "symbol": "BTC",
  "date": "2026-09-10T00:00:00.000Z",
  "value": 76547.51051673751,
  "retrievedAt": "2026-10-10T09:00:00.000Z",
  "note": null,
  "granularity": "1d",
  "seriesKey": "1e31218a-e44e-4285-820c-8282ee222035",
  "close": 76547.51051673751,
  "volume": 15639703479.254776,
  "units": { "close": "usd" }
}
```

Values are taken from the provider's documentation example. Timeseries points are unpacked from the API's compact arrays into named fields using its point schema, with the unix timestamp converted to an ISO `date` and the first metric copied to `value`. Table rows keep every field the provider returns, with the common columns (`id`, `name`, `slug`, `symbol`, `date`) filled from them.

### FAQ

#### What is the Blockworks API, and how does it relate to the Messari API?

Blockworks is a crypto media and data company that acquired Messari in June 2026. The Blockworks API at api.blockworks.com is now the single REST interface to both companies' data: 15+ API families over 40k+ assets, documented publicly at docs.blockworks.com. The older Messari API is in maintenance. This actor calls only the current Blockworks routes, checked against the docs and the live host on 2026-10-10.

#### Do I need my own Blockworks API key?

Yes. This actor is bring your own API key and never ships one. The key is stored as an Apify secret, sent only in the documented `X-Blockworks-API-Key` header, and kept out of every log line. Without a key the run stops immediately with a clear message and no charge.

#### How do I get the top 100 crypto assets by market cap?

Use the screener on the `assets` table with the filter `{"circulatingMarketcapRankLte": 100}`, sort by `circulatingMarketcapRank` ascending, and run. Each row is one asset with its asset ID, slug, symbol, sectors, flags, contracts and market cap.

#### How do I download historical Bitcoin and Ethereum prices?

Pick the timeseries mode, the `asset-price` model and the `1d` granularity, list `bitcoin` and `ethereum` as series keys, and set a timeframe such as `365d` or a start and end date. Each row is one daily VWAP candle with open, high, low, close and volume in USD.

#### Can I get token unlock schedules?

Yes. The `token-unlocks` timeseries model gives the daily unlock schedule of an asset, past and future, keyed by the asset (slugs and symbols are resolved for you). Points run ahead of today to the end of the vesting schedule.

#### Which tables and models are there?

46 tables and 61 timeseries models, from assets, markets and perpetuals to fundraising, M\&A, stablecoins, tokenized real-world assets, ETFs, treasury companies, DeFi protocols, news, research and token transparency. Run the catalog modes for the live list with every column, filter, granularity and access tier.

#### What are Monitoring developments?

Dated crypto events (a listing, a hack, a governance vote, an unlock) surfaced by agents across 700+ sources and verified by Blockworks intel analysts, each with a summary, categories, importance, source documents and resolved assets. Events group related developments over time.

#### What do I pay?

Pay per result: 0.005 USD per timeseries point, catalog model or category, 0.01 USD per data table row, and 0.02 USD per Monitoring development or event. Requests that find nothing are free. Your Blockworks subscription applies separately.

#### What happens if my key is wrong or my plan does not cover a table?

Blockworks checks the key before anything else and answers 403. The run then ends cleanly with a status message saying whether the key was rejected or the dataset is not on your plan, before anything is charged. A row, filter value or granularity the provider refuses becomes a free row with the provider's own explanation, and the run goes on.

### Keyword map

crypto data API, Messari API, Blockworks API, crypto asset data, crypto market cap API, crypto price history API, Bitcoin historical price API, crypto screener API, token unlocks API, vesting schedule data, crypto fundraising data, crypto funding rounds API, stablecoin data API, tokenized assets data, crypto ETF data, protocol revenue API, DeFi data API, crypto mindshare and sentiment, crypto news API, crypto research reports, crypto intel alerts.

### Terms and data use

Your Blockworks agreement decides what you may do with the data, and this actor does not change it. The Messari API terms that the Blockworks data API inherits describe it as intended for internal purposes and uses only, and ask anyone who wants to redistribute data from it to contact the provider's sales team first. Keep the run's dataset private, and do not republish it, unless your agreement allows sharing it.

Which routes were checked live: without a key the Data API routes normally, so every Data API route this actor builds was confirmed against an invented-route control (an invented path or model answers 404, a gated model 401, the catalogs 200), and the 46 tables and 61 timeseries models match the live catalogs. The Monitoring routes check authentication before routing, so they rest on the provider's published OpenAPI document. With any key sent, the gateway checks the key before routing. The legacy token-unlocks v1 routes are not used: they now answer with a crypto payment challenge, and the same schedules come from the `token-unlocks` timeseries model.

# Actor input Schema

## `apiKey` (type: `string`):

Your own Blockworks API key (the same key covers the Data API and Monitoring, and legacy Messari keys keep working). Create one at app.blockworks.com/account/api. It is sent only in the X-Blockworks-API-Key header to api.blockworks.com. You can also set it as the DATA_API_KEY secret.

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

The screener lists rows of any Data API table with filters and sorting. Lookup reads rows by slug, symbol or ID. Timeseries reads history for up to 20 series per call. Developments and events read the Monitoring API's analyst-verified intel. The catalogs list every model with its columns and access tier.

## `tabularModel` (type: `string`):

The Data API table to read, used by the screener and lookup modes. Lookup by slug, symbol or ID works on assets, blockchains, markets, perpetual markets, funding rounds, funds, fund managers, investors, acquisition deals, news, research reports and token transparency tables.

## `filters` (type: `object`):

Screener filters as a JSON object of field plus operator names and values, exactly as the table documents them: {"circulatingMarketcapRankLte": 100, "isStablecoinEq": false, "sectorIsOneOf": \["DeFi"]}. Operators are Eq, NotEq, Gt, Gte, Lt, Lte, IsOneOf, IsNotOneOf, Contains, Includes, IncludesAnyOf and their negations. A name the chosen table does not document is dropped with a warning; the tabular catalog lists each column's operators.

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

A sortable field of the chosen table, such as circulatingMarketcap or circulatingMarketcapRank for assets. Leave empty for the table's default order.

## `sortDirection` (type: `string`):

Ascending or descending. Default keeps the table's own order.

## `selections` (type: `array`):

Optional field names to return, one per line, such as assetID, name, symbol, circulatingMarketcap. For timeseries they name the metrics, such as close and volume. Empty returns every field.

## `identifiers` (type: `array`):

Rows to look up, one per line: a primary key, or a slug or symbol where the table accepts one, such as bitcoin, ETH or solana for assets.

## `timeseriesModel` (type: `string`):

The timeseries model to read. Asset models (price, market cap, supply, volatility, Sharpe, mindshare, sentiment, token unlocks) take asset slugs or symbols, which are resolved to asset IDs. Sector and exchange region models take names such as DeFi or Asia.

## `granularity` (type: `string`):

Resolution of the points. Each model supports only some of these (listed next to the model name); 1d is the most widely available, 1n is a calendar month.

## `seriesKeys` (type: `array`):

The series to read, one per line: asset slugs, symbols or IDs for asset models (bitcoin, ETH), blockchain or market slugs or IDs, sector names for sector models, or the IDs from the matching table for the rest. Empty reads every series on models that allow it.

## `timeframe` (type: `string`):

The window ending now: ytd, mtd, qtd, 30d, 12h, 52w, 365d, or a calendar year or month such as 2025 or 2025-06. There is no 1y: use 365d. Ignored when a start or end date is set.

## `startDate` (type: `string`):

Optional start as YYYY-MM-DD, an RFC3339 time or unix seconds. Used by the timeseries mode, and by developments and events (against their start time).

## `endDate` (type: `string`):

Optional end as YYYY-MM-DD, an RFC3339 time or unix seconds.

## `assetIds` (type: `array`):

Asset slugs or UUIDs to filter developments and events by, one per line, such as bitcoin or solana. Unknown tokens are dropped silently by the API.

## `intelCategories` (type: `array`):

Category slugs from the categories mode, one per line, such as security_and_hacks.

## `intelSubcategories` (type: `array`):

Subcategory slugs from the categories mode, one per line.

## `minimumImportance` (type: `string`):

Only developments or events at or above this importance.

## `verifiedOnly` (type: `boolean`):

Only items an intel analyst has verified.

## `actionableOnly` (type: `boolean`):

Only items flagged actionable.

## `governanceOnly` (type: `boolean`):

Only governance-related items.

## `preTgeOnly` (type: `boolean`):

Only items about assets before their token generation event.

## `assetSectors` (type: `array`):

Asset sectors to filter by, one per line.

## `assetSubsectors` (type: `array`):

Asset subsectors to filter by, one per line.

## `eventIds` (type: `array`):

Event UUIDs or slug-with-id forms to filter by, one per line. Unknown ones are refused by the API.

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

Free-text search over developments or events, up to 200 characters.

## `catalogScope` (type: `string`):

Every model, only models published to the public API, or only the models your key may query.

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

Ceiling on rows returned (and charged) in this run.

## `requestsPerMinute` (type: `integer`):

Pacing ceiling for calls to the Blockworks API.

## Actor input object example

```json
{
  "mode": "tabular",
  "tabularModel": "assets",
  "filters": {
    "circulatingMarketcapRankLte": 100
  },
  "sortDirection": "default",
  "timeseriesModel": "asset-price",
  "granularity": "1d",
  "seriesKeys": [
    "bitcoin",
    "ethereum"
  ],
  "timeframe": "30d",
  "minimumImportance": "any",
  "verifiedOnly": false,
  "actionableOnly": false,
  "governanceOnly": false,
  "preTgeOnly": false,
  "catalogScope": "all",
  "maxResults": 200,
  "requestsPerMinute": 120
}
```

# Actor output Schema

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

One row per table row, timeseries point, development, event, category or catalog model.

# 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 = {
    "filters": {
        "circulatingMarketcapRankLte": 100
    },
    "seriesKeys": [
        "bitcoin",
        "ethereum"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/crypto-asset-data-api").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 = {
    "filters": { "circulatingMarketcapRankLte": 100 },
    "seriesKeys": [
        "bitcoin",
        "ethereum",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/crypto-asset-data-api").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 '{
  "filters": {
    "circulatingMarketcapRankLte": 100
  },
  "seriesKeys": [
    "bitcoin",
    "ethereum"
  ]
}' |
apify call nabeelbaghoor/crypto-asset-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/crypto-asset-data-api"
        }
    }
}
```

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/Ijk0MqJoy7LiaItdw/builds/skGGWyS3DKHhrrqB1/openapi.json