# Introduction

growthepie is a data platform for Ethereum Mainnet, Layer 2s, Ethereum-aligned chains, apps, and data availability layers. The growthepie API exposes metadata, chain coverage, project coverage, and time-series metrics that help developers answer questions such as which chains are covered, what a metric means, how fresh the data is, and how to compare networks over time.

This documentation is designed for both human developers and AI coding tools. The docs lead with plain-English definitions, use consistent terms such as `origin_key`, `metric_key`, `value`, and `date`, and link each question to a single-purpose page with runnable examples.

## Start Here

* If you are new to the API, start with [Quickstart](/getting-started/getting-started/quickstart).
* If you need to choose an endpoint, see [Choose The Right Endpoint](/getting-started/getting-started/choose-the-right-endpoint).
* If you need the canonical list of supported chains and metrics, start with [Endpoint: master.json](/api-reference/api/master-json).
* If you want raw daily metric rows across covered chains, start with [Endpoint: fundamentals.json](/api-reference/api/fundamentals-json) or [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json).

## Canonical Terms

* `origin_key`: The canonical identifier for a chain, app, or other covered entity in growthepie data.
* `owner_project`: The canonical identifier for a covered app or project in project-level endpoints such as `labels/projects.json` and `apps/details/{owner_project}.json`.
* `metric_key`: The canonical identifier for a raw metric series such as `txcount` or `fees_paid_usd`.
* `metric_id`: The higher-level metric identifier used in richer detail endpoints such as `txcount`, `daa`, or `fees`.
* `value`: The numeric observation for a metric at a given point in time.
* `date`: The calendar date for daily export endpoints, formatted as `YYYY-MM-DD`.

## What growthepie Covers

* Chain-level metrics such as transaction count, active addresses, transaction costs, total value secured, stablecoin supply, revenue, and throughput.
* Richer per-chain JSON such as chain overview pages and metric detail pages.
* Project coverage via `labels/projects.json` and project detail JSON via `apps/details/{owner_project}.json`.
* Data availability coverage and data availability metrics exposed in `master.json`.

## Usage Limits And Freshness Safety

* Public API rate limit guidance: no more than 10 calls per minute.
* Ignore chains whose `deployment` is `DEV` or `ARCHIVED`. Those chains can expose stale data and should not be used in production analysis.
* The API is currently public, but growthepie may change API access or authentication requirements in the future.

## Data And API Terms

* Public growthepie data, chart exports, CSV downloads, and public API outputs are covered by the [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers).
* Unless otherwise stated, growthepie data may be used, shared, and adapted under the Creative Commons Attribution 4.0 International license with appropriate attribution.
* Preferred attribution: Source: growthepie, <https://www.growthepie.com>.
* Data is only available for chains that work with growthepie.
* Chain-level data is part of the Basic package. Application-level data is part of the Advanced package. More information: [growthepie data tiers](https://www.growthepie.com/sales#data-tiers)

## Source Of Truth

This docs set is aligned to the public API at `https://api.growthepie.com/`, the live `master.json` metadata, and the growthepie backend metric registry in `backend/src/config.py`.


# Getting Started

Start here if you are new to growthepie and want to make the first correct API request quickly.

The fastest path into the growthepie API is to learn three terms first: `origin_key`, `metric_id`, and `metric_key`. Once you know those three terms, you can choose the right endpoint for metadata, flat exports, or richer detail JSON without guessing.

## In One Minute

1. Fetch `master.json` to discover supported chains, metrics, and metadata.
2. Use `fundamentals.json` if you want daily rows across many metrics and chains.
3. Use `export/{metric}.json` if you want one metric across all covered chains.
4. Use `metrics/chains/{origin_key}/{metric_id}.json` if you want a rich per-chain metric response with summaries and multiple time granularities.

## First Three Questions To Ask

### What chain or entity am I querying?

Use `origin_key`. Example: `arbitrum`, `base`, `ethereum`, or `zksync_era`.

### What higher-level metric am I querying?

Use `metric_id`. Example: `txcount`, `daa`, `fees`, or `throughput`.

### What raw series key will I see in flat exports?

Use `metric_key`. Example: `txcount`, `daa`, `fees_paid_usd`, or `gas_per_second`.

## Recommended Reading Order

* [Quickstart](/getting-started/getting-started/quickstart)
* [Choose The Right Endpoint](/getting-started/getting-started/choose-the-right-endpoint)
* [What Is origin\_key?](/core-concepts/what-is-origin-key)
* [What Is metric\_key?](/core-concepts/what-is-metric-key)

## Related Pages

* [API Overview](/api-reference/api)
* [Endpoint: master.json](/api-reference/api/master-json)
* [Metric Reference Overview](/metric-reference/metric-reference)


# Quickstart

Copy-pasteable quickstart examples for the growthepie API in curl, Python, and JavaScript.

This page answers the most common first question directly: how do I make a correct growthepie API request right now? The examples below are complete, runnable, and use real public endpoints that do not require authentication.

## Key Facts

* Base URL: `https://api.growthepie.com/`
* Auth: No authentication required for the public endpoints documented here
* Best first endpoint: `https://api.growthepie.com/v1/master.json`
* Flat export shape: `metric_key`, `origin_key`, `date`, `value`

## curl

```bash
curl -s https://api.growthepie.com/v1/export/txcount.json
```

## Python

```python
import requests

url = "https://api.growthepie.com/v1/export/txcount.json"
response = requests.get(url, timeout=30)
response.raise_for_status()

rows = response.json()
print(f"rows={len(rows)}")
print(rows[0])
```

## JavaScript / TypeScript

```ts
const url = "https://api.growthepie.com/v1/export/txcount.json";

const response = await fetch(url);
if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const rows = await response.json();
console.log(`rows=${rows.length}`);
console.log(rows[0]);
```

## Example Response

```json
[
  {
    "metric_key": "txcount",
    "origin_key": "arbitrum",
    "date": "2021-05-29",
    "value": 9.0
  }
]
```

## Real Task: Fetch One Chain's Transaction Count History

```python
import requests

url = "https://api.growthepie.com/v1/export/txcount.json"
rows = requests.get(url, timeout=30).json()

arbitrum_rows = [row for row in rows if row["origin_key"] == "arbitrum"]
print(arbitrum_rows[:3])
```

## FAQ

### What should I fetch before choosing an `origin_key`?

Fetch `master.json`. `master.json` is the canonical metadata file for supported chains and supported metrics.

### When should I use `fundamentals.json` instead?

Use `fundamentals.json` when you want many fundamental metrics together in one 90-day daily export.

## Related Pages

* [Choose The Right Endpoint](/getting-started/getting-started/choose-the-right-endpoint)
* [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json)
* [Fetch A Metric In curl](/recipes-tutorials/recipes/fetch-a-metric-in-curl)


# Choose The Right Endpoint

Choose the correct growthepie endpoint based on the developer task you need to solve.

Different growthepie endpoints answer different developer intents. This page maps each common task to the correct endpoint so you can retrieve the narrowest correct JSON file instead of starting from a broad export and filtering everything yourself.

## Endpoint Selector

| If your question is...                                                  | Use this endpoint                         | Why                                                                              |
| ----------------------------------------------------------------------- | ----------------------------------------- | -------------------------------------------------------------------------------- |
| Which chains and metrics are supported?                                 | `v1/master.json`                          | `master.json` is the canonical metadata index                                    |
| What are the last 90 days of fundamental metrics across covered chains? | `v1/fundamentals.json`                    | Returns flat daily rows for many metrics together                                |
| What is the full history for one metric such as `txcount`?              | `v1/export/{metric}.json`                 | Returns flat rows for one fundamental metric across chains                       |
| What does the chain overview for `arbitrum` look like?                  | `v1/chains/arbitrum/overview.json`        | Returns highlights, events, rankings, KPI cards, and ecosystem context           |
| What is the rich metric detail view for `txcount` on `arbitrum`?        | `v1/metrics/chains/arbitrum/txcount.json` | Returns multiple time granularities, changes, and summary values                 |
| Which apps or projects are covered?                                     | `v1/labels/projects.json`                 | Returns project coverage metadata                                                |
| Which projects have actual datapoints and can be used with app details? | `v1/labels/projects_filtered.json`        | Returns the subset of projects with real datapoints such as `txcount`            |
| What does the project detail page for `uniswap` look like?              | `v1/apps/details/uniswap.json`            | Returns project-level metrics, KPI cards, first-seen dates, and contracts tables |

## Rule Of Thumb

* Start with `master.json` if you need discovery.
* Use flat exports if you want rows that load cleanly into spreadsheets, pandas, SQL, or notebooks.
* Use richer detail endpoints if you want pre-aggregated summaries, rankings, rolling windows, multiple time granularities, or project-level breakdowns.

## Caveats

* `fundamentals.json` is intentionally limited to the last 90 days.
* `export/{metric}.json` is only available for public fundamental metrics.
* Some legacy or internal-looking paths exist in backend code but are not public or not consistently accessible. This docs set only covers verified public endpoints.

## Related Pages

* [API Overview](/api-reference/api)
* [Endpoint: fundamentals.json](/api-reference/api/fundamentals-json)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)


# What Is growthepie?

Plain-English definition of growthepie and what growthepie data covers.

growthepie is a data platform for Ethereum Mainnet, Layer 2s, Ethereum-aligned chains, apps, and data availability layers. growthepie tracks usage, value, and network economics so developers can compare chains, inspect app activity, and work with structured public data instead of scraping dashboards.

## What is growthepie's mission?

To visualize Ethereum's story through data. Making data on the Ethereum ecosystem easily accessible to all ecosystem participants and help tell the story.

## Key Facts

* growthepie exposes public JSON at `https://api.growthepie.com/`
* growthepie tracks chains, projects, metrics, and data availability metadata
* `master.json` is the canonical metadata entry point
* Flat exports use `metric_key`, `origin_key`, `date`, and `value`
* Data is only available for chains that work with growthepie
* Chain-level data belongs to the Basic package and application-level data belongs to the Advanced package. More info: [growthepie data tiers](https://www.growthepie.com/sales#data-tiers)

## What growthepie Measures on Chain level

* Chain activity metrics such as `txcount`, `daa`, and `throughput`
* Value and market metrics such as `tvl`, `stables_mcap`, `market_cap`, and `fdv`
* Business metrics such as `fees`, `rent_paid`, `profit`, and `app_revenue`
* Coverage metadata such as supported chains, DA layers, and projects

## What growthepie Measures on Application level

* Application activity metrics such as `txcount`, `daa`, and `gas_fees`
* soon more market data, developer data, and much more

## Usage Rules

* Public growthepie data, chart exports, CSV downloads, and public API outputs are covered by the [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers).
* Preferred attribution: Source: growthepie, <https://www.growthepie.com>.

## FAQ

### Is growthepie only a dashboard?

No. growthepie is a website, a public data source, and a research + storytelling company for the Ethereum ecosystem.

### Is growthepie only about Layer 2s?

No. growthepie covers Ethereum Mainnet as well as Layer 2s, Ethereum-aligned chains, apps, and DA layers.

### Can I use growthepie data in research?

Yes. You may use growthepie data for research, journalism, dashboards, applications, reports, models, and commercial or non-commercial products, provided that you follow the [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers).

## Related Pages

* [What Is origin\_key?](/core-concepts/what-is-origin-key)
* [What Is metric\_key?](/core-concepts/what-is-metric-key)
* [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers)
* [Endpoint: master.json](/api-reference/api/master-json)


# What Is origin\_key?

Learn what origin\_key means in growthepie and where to find valid origin\_key values.

`origin_key` is the canonical growthepie identifier for a covered entity, most commonly a chain. You use `origin_key` values such as `arbitrum`, `base`, `ethereum`, or `zksync_era` to filter flat exports and to address richer endpoints such as `chains/{origin_key}/overview.json`.

## Key Facts

* `origin_key` is lowercase and stable enough to be used in code and URLs
* The canonical list of public chain `origin_key` values lives in `master.json`
* `origin_key` appears in flat export rows together with `metric_key`, `date`, and `value`
* `origin_key` is not a display name; for example, `arbitrum` maps to the display name `Arbitrum One`

## Example

```json
{
  "metric_key": "txcount",
  "origin_key": "arbitrum",
  "date": "2021-05-29",
  "value": 9.0
}
```

## Synonyms And Nearby Terms

* Search synonym: chain key
* Search synonym: chain slug
* Not the same thing: display name
* Not the same thing: `owner_project`

## FAQ

### Where do I get valid `origin_key` values?

Use `master.json`. Each chain entry in `master.json.chains` includes metadata and supported metrics.

### Does `origin_key` only refer to chains?

In the public endpoints documented on this site, `origin_key` is primarily used for chains. Project coverage uses `owner_project` instead.

## Related Pages

* [Supported Chains And origin\_key](/entity-coverage-reference/entity-coverage-reference/supported-chains-and-origin-key)
* [Endpoint: master.json](/api-reference/api/master-json)


# What Is owner\_project?

Learn what owner\_project means in growthepie and where to find valid owner\_project values.

`owner_project` is the canonical growthepie identifier for a covered app or project. You use `owner_project` values such as `uniswap` to map project metadata from `labels/projects.json` and to fetch project detail JSON from `apps/details/{owner_project}.json`.

In practice, `owner_project` is the application-level key. growthepie application metrics are mostly based on smart contracts mapped to that `owner_project`.

## Key Facts

* `owner_project` is the canonical project key for app-level coverage
* The canonical list of public `owner_project` values lives in `labels/projects.json`
* `owner_project` is not the same thing as a display name
* `owner_project` is not the same thing as `origin_key`
* App-level metrics are mostly based on mapped smart contracts

## Example

```json
[
  "uniswap",
  "Uniswap",
  "Uniswap is a decentralized exchange protocol."
]
```

## Synonyms And Nearby Terms

* Search synonym: project key
* Search synonym: app slug
* Not the same thing: display name
* Not the same thing: `origin_key`

## FAQ

### Where do I get valid `owner_project` values?

Use `labels/projects.json` for the full metadata universe. Use `labels/projects_filtered.json` when you need the subset of `owner_project` values that have actual datapoints and can be used with app-detail endpoints.

### What do I use `owner_project` for after discovery?

Use `owner_project` in app-level detail paths such as `apps/details/{owner_project}.json`.

## Related Pages

* [Projects And owner\_project](/entity-coverage-reference/entity-coverage-reference/projects-and-owner-project)
* [Endpoint: labels/projects.json](/api-reference/api/labels-projects-json)
* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)


# What Is metric\_key?

Learn what metric\_key means in growthepie and how metric\_key differs from metric\_id.

`metric_key` is the canonical identifier for a raw exported series in growthepie data. You see `metric_key` values directly in flat export rows such as `txcount`, `daa`, `fees_paid_usd`, `fees_paid_eth`, or `gas_per_second`.

## Key Facts

* `metric_key` appears in flat row exports
* Some higher-level metrics map to one raw `metric_key`, such as `txcount`
* Some higher-level metrics map to multiple raw `metric_key` values, usually currency pairs such as USD and ETH
* `metric_key` is not the same thing as `metric_id`

## metric\_id vs metric\_key

| Term         | Example         | Used where                                                    |
| ------------ | --------------- | ------------------------------------------------------------- |
| `metric_id`  | `fees`          | Rich detail paths such as `metrics/chains/arbitrum/fees.json` |
| `metric_key` | `fees_paid_usd` | Flat row payloads such as `fundamentals.json`                 |

## Example

The higher-level metric `fees` maps to two raw `metric_key` values:

* `fees_paid_usd`
* `fees_paid_eth`

## FAQ

### Why do some metrics have both USD and ETH keys?

Currency-denominated metrics often expose both USD and ETH series in the backend metric registry and in `master.json`.

### Where do I find the mapping from `metric_id` to `metric_key`?

Use `master.json.metrics`. Each metric entry includes the canonical `metric_keys` array.

## Related Pages

* [Metric Reference Overview](/metric-reference/metric-reference)
* [Endpoint: master.json](/api-reference/api/master-json)


# Chain vs App vs Ecosystem Metrics

Understand the difference between chain metrics, app metrics, and ecosystem context in growthepie.

growthepie exposes multiple scopes of data. Chain metrics answer high-level network questions for one `origin_key`. Application metrics answer project questions for one `owner_project`, and those application metrics are mostly based on smart contracts mapped to that project.

## Key Facts

* Chain metrics answer questions about a chain such as `arbitrum` or `base`
* Application metrics answer questions about a project such as `uniswap`, `polymarket`, or `circlefin`.
* Application metrics are mostly based on smart contracts mapped to an `owner_project`
* Ecosystem context appears in richer endpoints such as `chains/{origin_key}/overview.json`

## Scope Definitions

### Chain metrics

Chain metrics describe a covered network. Chain metrics are the right scope when you want high-level information about usage, economics, or value on a chain.

Common chain metrics include:

* `txcount`
* `daa`
* `fees`
* `txcosts`
* `throughput`
* `tvl`
* `stables_mcap`
* `rent_paid`
* `profit`
* `market_cap`
* `fdv`

### App metrics

App metrics describe one application or project. In growthepie, the public app scope is keyed by `owner_project`, and the metrics are mostly based on smart contracts mapped to that `owner_project`.

Common app metrics currently include:

* `txcount`
* `daa`
* `gas_fees`
* `success_rate`
* `token_price`
* `token_volume`
* `market_cap`

The canonical public starting points are `labels/projects.json` for project discovery, `labels/projects_filtered.json` for projects with actual datapoints, and `apps/details/{owner_project}.json` for project detail.

### Ecosystem context

Ecosystem context combines chain-level and app-level information. For example, the chain overview endpoint includes `ecosystem.active_apps` and an `ecosystem.apps` table.

## Caveats

* Not every chain supports every metric. Use `master.json.chains.{origin_key}.supported_metrics`.
* Not every app-oriented or internal endpoint is public. This docs set only documents public endpoints that are currently accessible.
* Not every chain metric exists at the application level.
* The application metric set can vary by `owner_project`.

## Related Pages

* [What Is owner\_project?](/core-concepts/what-is-owner-project)
* [Projects And owner\_project](/entity-coverage-reference/entity-coverage-reference/projects-and-owner-project)
* [Endpoint: chains/{origin\_key}/overview.json](/api-reference/api/chain-overview-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)


# Time Granularity, Freshness, And Update Cadence

Learn how growthepie uses daily, weekly, monthly, quarterly, and hourly data across endpoints.

growthepie uses more than one time model. Flat exports such as `fundamentals.json` and `export/{metric}.json` are daily, while richer metric detail endpoints can include daily, weekly, monthly, quarterly, and for some metrics hourly time series.

## Key Facts

* Flat exports use daily rows with `date` formatted as `YYYY-MM-DD`
* Rich metric detail endpoints can expose `daily`, `weekly`, `monthly`, `quarterly`, and optional `hourly` series
* `fundamentals.json` is limited to the last 90 days
* Richer endpoints expose `last_updated_utc`

## How Freshness Works

* Use `last_updated_utc` when the response includes it
* Use the most recent `date` in a flat export when the response is a raw array
* Treat hourly series as available only when `master.json.metrics.{metric}.hourly_available` is `true`

## Example

`txcount` is a metric with hourly availability. The rich endpoint `metrics/chains/arbitrum/txcount.json` includes:

* `timeseries.daily`
* `timeseries.weekly`
* `timeseries.monthly`
* `timeseries.quarterly`
* `timeseries.hourly`

## FAQ

### Is `fundamentals.json` full history?

No. `fundamentals.json` is a rolling 90-day daily export.

### Where do I get full history for one metric?

Use `export/{metric}.json` for flat rows or `metrics/chains/{origin_key}/{metric_id}.json` for richer series per chain.

## Related Pages

* [Endpoint: fundamentals.json](/api-reference/api/fundamentals-json)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)


# How To Interpret Values, Units, And Dates

Learn how to interpret value, units, currencies, timestamps, and dates in growthepie responses.

The same numeric field name, `value`, is used across flat exports, but the unit behind `value` depends on the metric. You should always read `value` together with the endpoint, the `metric_key`, and the unit metadata from `master.json.metrics`.

## Key Facts

* `value` is numeric but not self-describing
* `date` is a daily string in flat exports
* Rich endpoints often use `unix` timestamps in milliseconds
* Currency metrics usually expose both USD and ETH `metric_key` values

## Common Unit Patterns

| Metric family  | Example                     | Unit pattern                    |
| -------------- | --------------------------- | ------------------------------- |
| Count          | `txcount`, `daa`            | Plain numeric value             |
| USD / ETH pair | `fees`, `tvl`, `market_cap` | Separate USD and ETH raw series |
| Throughput     | `gas_per_second`            | `Mgas/s`                        |

## Example

```json
{
  "metric_key": "fees_paid_usd",
  "origin_key": "arbitrum",
  "date": "2026-03-01",
  "value": 123456.78
}
```

Interpretation:

* `metric_key` tells you this is the USD series for `fees`
* `origin_key` tells you the chain is `arbitrum`
* `date` is the daily observation date
* `value` is the numeric amount for that series and date

## Caveats

* Do not assume that all `value` fields are USD.
* Do not assume that all timestamps are `date` strings.
* Do not assume that monthly values are always sums. Monthly aggregation depends on the metric.

## Related Pages

* [What Is metric\_key?](/core-concepts/what-is-metric-key)
* [Metric Reference Overview](/metric-reference/metric-reference)


# API Overview

Use this page to understand the growthepie API base URL, public endpoint families, response conventions, and the fastest path to the right JSON file.

The growthepie API is a public JSON API rooted at `https://api.growthepie.com/`. The fastest way to work with the API is to start with `master.json` for metadata, use `fundamentals.json` or `export/{metric}.json` for flat daily rows, and use the richer `chains/.../overview.json`, `metrics/.../{metric_id}.json`, or `apps/details/{owner_project}.json` endpoints when you need summaries, rankings, rolling windows, or multi-granularity time series.

The API currently exposes JSON files rather than a published OpenAPI specification. That means the canonical source of truth for supported chains, metrics, units, and coverage is `master.json`, plus the backend metric registry mirrored in the docs on this site.

## Base URL

```
https://api.growthepie.com/
```

## Authentication

No authentication is required for the public endpoints documented in this site.

## Availability Notice

The growthepie API is currently public. growthepie may change API access, packaging, or authentication requirements in the future, so production integrations should avoid assuming that the current access model is permanent.

## Rate Limits

* Public usage guidance: do not make more than 10 API calls per minute.
* If you are building an AI agent, prefer fewer broader requests such as `master.json` plus one targeted detail endpoint instead of many repeated discovery calls.

## Data And API Terms

Public growthepie data, chart exports, CSV downloads, and public API outputs are covered by the [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers). Unless otherwise stated, growthepie data may be used, shared, and adapted under the Creative Commons Attribution 4.0 International license with appropriate attribution.

## Coverage And Data Packages

* Data is only available for chains that work with growthepie.
* Chain-level data belongs to the Basic package.
* Application-level data such as `apps/details/{owner_project}.json` belongs to the Advanced package.
* Commercial packaging details: [growthepie data tiers](https://www.growthepie.com/sales#data-tiers)

## Chain Metrics vs Application Metrics

Use chain metrics when the question is about a network such as `arbitrum`, `base`, or `ethereum`. Use application metrics when the question is about a smart-contract application mapped to an `owner_project` such as `uniswap`, `polymarket`, or `circlefin`.

### Chains

Chains are the high-level network entities in growthepie. Chain metrics describe network-wide activity, economics, and value for one `origin_key`.

Common chain metrics include:

* `txcount`
* `daa`
* `fees`
* `txcosts`
* `throughput`
* `tvl`
* `stables_mcap`
* `rent_paid`
* `profit`
* `market_cap`
* `fdv`

### Applications

Applications are smart contracts mapped to `owner_project` values. Application metrics are mostly derived from activity on those mapped contracts, and the public app-detail endpoint returns those metrics for one project at a time.

Common app metrics currently include:

* `txcount`
* `daa`
* `gas_fees`
* `success_rate`
* `token_price`
* `token_volume`
* `market_cap`

### Practical Rule

* If the identifier is `origin_key`, you are usually working with chain-level data.
* If the identifier is `owner_project`, you are usually working with application-level data.
* Not every chain metric has an application-level equivalent, and the app metric set can vary by project.

## Response Conventions

* Flat export endpoints such as `fundamentals.json` and `export/{metric}.json` return arrays of rows with `metric_key`, `origin_key`, `date`, and `value`.
* Richer detail endpoints such as `chains/{origin_key}/overview.json`, `metrics/chains/{origin_key}/{metric_id}.json`, and `apps/details/{owner_project}.json` return objects with `last_updated_utc` and nested structured payloads.
* Daily export endpoints use `date` values formatted as `YYYY-MM-DD`.
* Richer time-series endpoints often use `unix` timestamps in milliseconds instead of `date` strings.
* Project-level endpoints use `owner_project` as the canonical project identifier.

## Public Endpoint Families

| Endpoint                                          | Use when                                               | Returns                                                                                          |
| ------------------------------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| `v1/master.json`                                  | You need metadata and coverage                         | Chains, metrics, DA layers, sources, and canonical metadata                                      |
| `v1/fundamentals.json`                            | You need a broad daily export                          | Flat daily rows for supported fundamental metrics in the last 90 days                            |
| `v1/export/{metric}.json`                         | You need one metric across all covered chains          | Flat daily rows for a single fundamental metric                                                  |
| `v1/fees/table.json`                              | You need the latest cross-chain transaction-cost table | Per-chain hourly fee-table payload with cost, TPS, throughput, and normalized comparison values  |
| `v1/chains/{origin_key}/overview.json`            | You need chain summaries                               | Highlights, events, rankings, KPI cards, achievements, and ecosystem context                     |
| `v1/metrics/chains/{origin_key}/{metric_id}.json` | You need a rich metric detail page                     | Daily, weekly, monthly, quarterly, and optional hourly time series plus summary values           |
| `v1/labels/projects.json`                         | You need project coverage                              | Project metadata as a typed table                                                                |
| `v1/labels/projects_filtered.json`                | You need projects with real datapoints                 | Filtered project metadata for `owner_project` values that have actual activity such as `txcount` |
| `v1/apps/details/{owner_project}.json`            | You need app or project detail                         | Project-level metrics, KPI cards, first-seen dates, chain breakdowns, and contracts tables       |

## Stale Data Guardrail

Check `master.json` before trusting a chain in production workflows. If a chain entry has `deployment` or `deployment_flag` set to `DEV` or `ARCHIVED`, treat that chain as stale and exclude it from production analysis.

## Example Request

```bash
curl -s https://api.growthepie.com/v1/master.json
```

## FAQ

### Which endpoint should I start with?

Start with `master.json`. `master.json` tells you which `origin_key` values and `metric_id` values are supported before you query a narrower endpoint.

### How do I fetch app-level details for one project?

Use `apps/details/{owner_project}.json`. The safest discovery source is `labels/projects_filtered.json`, because the app detail endpoint is only available for `owner_project` values in that filtered subset.

### What should I do if I publish growthepie data?

Follow the [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers). Preferred attribution is: Source: growthepie, <https://www.growthepie.com>.

### Is there a published OpenAPI spec?

Not at the moment. This docs set documents the current public JSON surface directly from the live API and backend source of truth.

### Will the API always stay public?

Not necessarily. The API is currently public, but growthepie may change access or authentication requirements in the future.

### Should I use `metric_id` or `metric_key`?

Use `metric_id` when the endpoint path expects a higher-level metric such as `txcount` or `fees`. Use `metric_key` when you are reading raw exported rows such as `fees_paid_usd`.

## Related Pages

* [Quickstart](/getting-started/getting-started/quickstart)
* [Chain vs App vs Ecosystem Metrics](/core-concepts/chain-vs-app-vs-ecosystem-metrics)
* [Endpoint: master.json](/api-reference/api/master-json)
* [Endpoint: fundamentals.json](/api-reference/api/fundamentals-json)
* [Endpoint: fees/table.json](/api-reference/api/fees-table-json)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)
* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)
* [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers)


# Authentication

Authentication requirements for the public growthepie API.

The public growthepie endpoints documented on this site do not require authentication. You can query the documented JSON files directly with `curl`, Python `requests`, `fetch`, notebooks, or spreadsheet connectors.

The API is currently public, but growthepie may change API access or authentication requirements in the future.

## Key Facts

* Public base URL: `https://api.growthepie.com/`
* Public auth requirement: none
* Public content type: JSON
* Public usage guidance: do not exceed 10 calls per minute
* Availability note: public today, but access rules can change in the future

## Example Request

```bash
curl -s https://api.growthepie.com/v1/master.json
```

## Related Pages

* [API Overview](/api-reference/api)
* [Endpoint: master.json](/api-reference/api/master-json)


# Endpoint: master.json

Reference for the growthepie master.json endpoint, the canonical metadata index for chains, metrics, and coverage.

`master.json` is the canonical metadata index for the public growthepie API. `master.json` answers the core discovery questions directly: which chains are covered, which metrics are supported, what units each metric uses, which chains support each metric, which chains should be excluded because they are stale, and when the metadata was last updated.

## Request

```
GET https://api.growthepie.com/v1/master.json
```

## Key Facts

* Auth: not required
* Best use case: discovery, metadata, coverage, and schema-aware clients
* Response type: object
* Includes: `chains`, `metrics`, `da_layers`, `da_metrics`, `sources`, `maturity_levels`, `last_updated_utc`
* Chain deployment safety field: `deployment` in the current live API, and `deployment_flag` if present on other environments

## Example Response

```json
{
  "current_version": "v1",
  "last_updated_utc": "2026-03-27 05:30:09",
  "chains": {
    "arbitrum": {
      "name": "Arbitrum One",
      "url_key": "arbitrum",
      "supported_metrics": [
        "tvl",
        "txcount",
        "daa",
        "stables_mcap",
        "fees",
        "rent_paid",
        "profit",
        "txcosts",
        "fdv",
        "market_cap",
        "throughput",
        "app_revenue"
      ]
    }
  },
  "metrics": {
    "txcount": {
      "name": "Transaction Count",
      "metric_keys": ["txcount"],
      "hourly_available": true
    }
  }
}
```

## When To Use master.json

* Before validating an `origin_key`
* Before validating a `metric_id`
* Before deciding whether a metric has hourly detail
* Before deciding whether a chain supports a given metric
* Before excluding stale chains whose `deployment` or `deployment_flag` is `DEV` or `ARCHIVED`

## FAQ

### Should I hardcode supported chains?

Prefer `master.json` over hardcoding. `master.json` is the intended machine-readable discovery file for chain and metric coverage.

### Where do I find the raw `metric_key` mapping?

Use `master.json.metrics.{metric_id}.metric_keys`.

### Which chains should I exclude because of stale data?

Exclude any chain whose `deployment` is `DEV` or `ARCHIVED`.

## Related Pages

* [What Is origin\_key?](/core-concepts/what-is-origin-key)
* [What Is owner\_project?](/core-concepts/what-is-owner-project)
* [What Is metric\_key?](/core-concepts/what-is-metric-key)
* [Supported Chains And origin\_key](/entity-coverage-reference/entity-coverage-reference/supported-chains-and-origin-key)


# Endpoint: fundamentals.json

Reference for the growthepie fundamentals.json endpoint.

`fundamentals.json` is the broad daily export endpoint for public fundamental metrics. `fundamentals.json` returns flat rows with `metric_key`, `origin_key`, `date`, and `value` for covered chains, filtered to the last 90 days.

## Request

```
GET https://api.growthepie.com/v1/fundamentals.json
```

## Key Facts

* Auth: not required
* Response type: array of flat rows
* Row fields: `metric_key`, `origin_key`, `date`, `value`
* Time window: last 90 days
* Notable inclusion: `aa_last7d` is included in the public fundamentals export

## Example Response

```json
[
  {
    "metric_key": "aa_last7d",
    "origin_key": "arbitrum",
    "date": "2026-01-01",
    "value": 907687.0
  },
  {
    "metric_key": "txcount",
    "origin_key": "arbitrum",
    "date": "2026-01-01",
    "value": 2525170.0
  }
]
```

## When To Use fundamentals.json

* You want many fundamental metrics in one file
* You want a flat daily export that loads well into spreadsheets, SQL, or pandas
* You only need the recent 90-day window

## When Not To Use fundamentals.json

* You need full history for one metric
* You need rich summary fields, rankings, or hourly time series
* You need project coverage metadata

## Caveats

* `fundamentals.json` is not full history.
* Currency-paired raw series that end in `_eth` are filtered out of this export.
* Coverage still depends on the chain and metric filtering defined in growthepie metadata.

## Related Pages

* [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json)
* [Load Into pandas](/recipes-tutorials/recipes/load-into-pandas)


# Endpoint: export/{metric}.json

Reference for the growthepie export/{metric}.json endpoint family.

`export/{metric}.json` returns the flat public export for one fundamental metric across covered chains. Use `export/{metric}.json` when you want a single metric such as `txcount`, `daa`, or `fees` without downloading the broader `fundamentals.json` file.

## Request

```
GET https://api.growthepie.com/v1/export/{metric}.json
```

Example:

```
GET https://api.growthepie.com/v1/export/txcount.json
```

## Supported Public Metric Paths

* `app_revenue`
* `daa`
* `fdv`
* `fees`
* `market_cap`
* `profit`
* `rent_paid`
* `stables_mcap`
* `throughput`
* `tvl`
* `txcosts`
* `txcount`

## Example Response

```json
[
  {
    "metric_key": "txcount",
    "origin_key": "arbitrum",
    "date": "2021-05-29",
    "value": 9.0
  }
]
```

## Notes On metric vs metric\_key

The path uses a higher-level metric identifier such as `fees` or `tvl`. The returned rows use raw `metric_key` values such as `fees_paid_usd`, `fees_paid_eth`, `tvl`, or `tvl_eth`.

## When To Use export/{metric}.json

* You want full metric history
* You want one metric across many chains
* You want a flat export for notebooks, CSV export, or a local cache

## Caveats

* The path parameter is the public metric identifier, not the raw `metric_key`.
* Multi-currency metrics can return more than one `metric_key` in the same file (usually USD and ETH).

## Related Pages

* [Metric Reference Overview](/metric-reference/metric-reference)
* [Fetch A Metric In curl](/recipes-tutorials/recipes/fetch-a-metric-in-curl)


# Endpoint: fees/table.json

Reference for the growthepie fees/table.json endpoint.

`fees/table.json` is the public cross-chain fee table endpoint. It returns per-chain hourly series for the latest transaction-cost style metrics used in the growthepie fee comparison table, which makes it a good fit when you want the latest cost snapshot across supported chains.

## Request

```
GET https://api.growthepie.com/v1/fees/table.json
```

## Key Facts

* Auth: not required
* Response type: object keyed by `chain_data`
* First-level keys under `chain_data`: one object per `origin_key`
* Current section structure: each chain exposes `hourly`
* Last verified in this docs refresh: April 1, 2026
* Live covered chains at that time: 14

## Current Hourly Metrics

The live payload currently exposes these hourly metrics per chain:

* `txcosts_median`
* `txcosts_native_median`
* `txcosts_avg`
* `txcosts_swap`
* `tps`
* `throughput`

For fee and cost series, rows use:

* `unix`
* `value_eth`
* `value_usd`
* `normalized`

For `tps` and `throughput`, rows use:

* `unix`
* `value`
* `normalized`

## Example Response

```json
{
  "chain_data": {
    "arbitrum": {
      "hourly": {
        "txcosts_median": {
          "types": ["unix", "value_eth", "value_usd", "normalized"],
          "data": [
            [1775037600000, 0.00000149534307, 0.0031, 0.37],
            [1775034000000, 0.00000125168, 0.0026, 0.24]
          ]
        },
        "tps": {
          "types": ["unix", "value", "normalized"],
          "data": [
            [1775037600000, 18.63083333333333, 0.9],
            [1775034000000, 19.433333333333334, 0.87]
          ]
        }
      }
    }
  }
}
```

## When To Use fees/table.json

* You want the latest cross-chain transaction-cost view
* You want hourly fee-table style data for supported chains in one request
* You want both ETH-denominated and USD-denominated transaction cost values

## When Not To Use fees/table.json

* You need full daily history for one metric
* You need the richer summary structure from `metrics/chains/{origin_key}/{metric_id}.json`
* You need project or app-level data

## Caveats

* `fees/table.json` is not a flat export endpoint.
* The payload is optimized for chain comparison UI and includes normalized values in addition to raw values.
* Despite the path name, the live payload currently includes `tps` and `throughput` alongside transaction-cost metrics.
* Coverage can change over time, so do not hardcode the current chain list.

## Related Pages

* [txcosts](/metric-reference/metric-reference/txcosts)
* [fees](/metric-reference/metric-reference/fees)
* [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)


# Endpoint: chains/{origin\_key}/overview\.json

Reference for the growthepie chain overview endpoint.

`chains/{origin_key}/overview.json` returns a rich summary for one chain. This endpoint is the right choice when you want highlights, events, rankings, KPI cards, achievements, and ecosystem context in one response instead of reconstructing a chain profile yourself from flat exports.

## Request

```
GET https://api.growthepie.com/v1/chains/{origin_key}/overview.json
```

Example:

```
GET https://api.growthepie.com/v1/chains/arbitrum/overview.json
```

## Key Response Sections

* `last_updated_utc`
* `data.chain_id`
* `data.chain_name`
* `data.highlights`
* `data.events`
* `data.ranking`
* `data.kpi_cards`
* `data.achievements`
* `data.blockspace`
* `data.ecosystem`

## Example Response

```json
{
  "last_updated_utc": "2026-03-27 05:35:04",
  "data": {
    "chain_id": "arbitrum",
    "chain_name": "Arbitrum One",
    "highlights": [
      {
        "metric_id": "txcount",
        "metric_name": "Transaction Count",
        "type": "lifetime_level_up",
        "date": "2026-03-24"
      }
    ],
    "ecosystem": {
      "active_apps": {
        "7d": 0
      }
    }
  }
}
```

## When To Use chain overview

* You are building a chain summary page
* You need Ethereum ecosystem rankings and KPI cards
* You want chain context plus ecosystem context in one request

## Caveats

* This endpoint is structured for overview use cases, not raw analytics row exports.
* The available ranking and KPI card metrics depend on chain support and growthepie's chain configuration.

## Related Pages

* [What Is origin\_key?](/core-concepts/what-is-origin-key)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)


# Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json

Reference for the growthepie per-chain metric detail endpoint.

`metrics/chains/{origin_key}/{metric_id}.json` returns a rich per-chain metric payload. This endpoint is the best choice when you need more than raw daily rows, such as rolling windows, weekly and monthly series, summary values, percentage changes, or optional hourly data.

## Request

```
GET https://api.growthepie.com/v1/metrics/chains/{origin_key}/{metric_id}.json
```

Example:

```
GET https://api.growthepie.com/v1/metrics/chains/arbitrum/txcount.json
```

## Key Response Sections

* `last_updated_utc`
* `details.metric_id`
* `details.metric_name`
* `details.timeseries`
* `details.changes`
* `details.summary`

## Example Response

```json
{
  "last_updated_utc": "2026-03-27 07:15:02",
  "details": {
    "metric_id": "txcount",
    "metric_name": "Transaction Count",
    "timeseries": {
      "daily": {
        "types": ["unix", "value"]
      },
      "hourly": {
        "types": ["unix", "value"]
      }
    },
    "changes": {
      "daily": {},
      "hourly": {}
    },
    "summary": {
      "last_1d": {
        "types": ["value"],
        "data": [2525170.0]
      }
    }
  }
}
```

## Time Granularity Behavior

* `daily` is the base time series
* `weekly`, `monthly`, and `quarterly` are available in richer metric payloads
* `hourly` is present only for metrics where `master.json.metrics.{metric_id}.hourly_available` is `true`

## When To Use metric detail

* You need daily plus higher-level rollups in one response
* You need summary fields such as `last_1d`, `last_7d`, or `last_30d`
* You are building a charting or analytics UI that mirrors the growthepie metric experience

## Caveats

* This endpoint uses `metric_id` in the path, not raw `metric_key`.
* Time-series rows in this endpoint typically use `unix` timestamps instead of `date` strings.

## Related Pages

* [What Is metric\_key?](/core-concepts/what-is-metric-key)
* [Time Granularity, Freshness, And Update Cadence](/core-concepts/time-granularity-freshness-and-update-cadence)


# Endpoint: labels/projects.json

Reference for the growthepie labels/projects.json endpoint.

`labels/projects.json` is the public project coverage endpoint. `labels/projects.json` returns project metadata as a typed table, which makes it useful when you want to map `owner_project` identifiers to human-readable names, descriptions, websites, categories, and other project attributes.

## Request

```
GET https://api.growthepie.com/v1/labels/projects.json
```

## Key Facts

* Auth: not required
* Response type: object with `last_updated_utc` and a typed table
* Table columns are listed in `data.types`
* Table rows are listed in `data.data`

## Example Response

```json
{
  "last_updated_utc": "2026-03-27 05:35:04",
  "data": {
    "types": [
      "owner_project",
      "display_name",
      "description",
      "main_github",
      "twitter",
      "website",
      "logo_path",
      "token_symbol",
      "sub_category",
      "main_category",
      "sub_categories"
    ],
    "data": [
      [
        "adsbaazar",
        "Adsbaazar",
        "Adsbaazar is an India-based vehicle branding and outdoor advertising service provider.",
        null,
        null,
        "https://www.adsbaazar.com/",
        null,
        null,
        "Stablecoin",
        "Token Transfers",
        ["stablecoin"]
      ]
    ]
  }
}
```

## When To Use labels/projects.json

* You need the canonical `owner_project` list
* You need a project display name or description
* You need app or project coverage metadata
* You need the full metadata universe, including projects that do not currently have datapoints

## Caveats

* `labels/projects.json` is a table-oriented payload, not a flat list of objects.
* Consumers should map `data.types` to each row in `data.data` before building objects locally.
* `labels/projects.json` includes all projects with metadata, not just projects with observed datapoints.
* For app-detail discovery, prefer `labels/projects_filtered.json`.

## Related Pages

* [Projects And owner\_project](/entity-coverage-reference/entity-coverage-reference/projects-and-owner-project)
* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)


# Endpoint: labels/projects\_filtered.json

Reference for the growthepie labels/projects\_filtered.json endpoint.

`labels/projects_filtered.json` is the filtered project coverage endpoint. `labels/projects_filtered.json` is a subset of `labels/projects.json` and only includes projects that currently have actual datapoints, such as `txcount`.

## Request

```
GET https://api.growthepie.com/v1/labels/projects_filtered.json
```

## Key Facts

* Auth: not required
* Response type: object with `last_updated_utc` and a typed table
* Use case: discover which `owner_project` values have actual datapoints
* App-detail dependency: `apps/details/{owner_project}.json` is only available for `owner_project` values in this filtered subset
* Last verified in this docs refresh: March 27, 2026
* Live filtered project count at that time: 757

## Example Response

```json
{
  "last_updated_utc": "2026-03-27 05:40:42",
  "data": {
    "types": [
      "owner_project",
      "display_name",
      "description",
      "main_github",
      "twitter",
      "website",
      "logo_path",
      "token_symbol",
      "txcount",
      "active_on",
      "ecosystem_rank",
      "sub_category",
      "main_category",
      "sub_categories",
      "features"
    ],
    "data": [
      [
        "polymarket",
        "Polymarket",
        "Polymarket is a decentralized blockchain-based prediction market platform.",
        "polymarket",
        "Polymarket",
        "https://polymarket.com/",
        "polymarket.png",
        null,
        125438595.0,
        {
          "polygon_pos": 125438595
        },
        1,
        "Prediction Markets",
        "Finance",
        [
          "erc4337",
          "prediction_markets"
        ],
        [
          "Dummy",
          "Swap",
          "Lending",
          "Bridge",
          "Trading"
        ]
      ]
    ]
  }
}
```

## When To Use labels/projects\_filtered.json

* You need the subset of projects that have real datapoints
* You need to discover valid `owner_project` values for `apps/details/{owner_project}.json`
* You need project coverage plus datapoint-aware fields such as `txcount`, `active_on`, or `ecosystem_rank`

## When Not To Use labels/projects\_filtered.json

* You need the full metadata universe, including projects that do not currently have datapoints

## Caveats

* `labels/projects_filtered.json` is a subset of `labels/projects.json`.
* This endpoint is the correct discovery source for app-detail endpoints.
* The payload is a typed table, not a list of JSON objects.

## Related Pages

* [Endpoint: labels/projects.json](/api-reference/api/labels-projects-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)
* [Projects And owner\_project](/entity-coverage-reference/entity-coverage-reference/projects-and-owner-project)


# Endpoint: apps/details/{owner\_project}.json

Reference for the growthepie apps/details/{owner\_project}.json endpoint.

`apps/details/{owner_project}.json` returns a rich project-level response for a covered app whose contracts have mapped activity. Use `apps/details/{owner_project}.json` when you need app-level metrics, KPI cards, first-seen dates by chain, chain-by-chain time series, and contracts tables for one `owner_project`.

## Request

```
GET https://api.growthepie.com/v1/apps/details/{owner_project}.json
```

Example:

```
GET https://api.growthepie.com/v1/apps/details/uniswap.json
```

## Key Facts

* Auth: not required
* Rate limit guidance: do not exceed 10 calls per minute
* Path parameter: `owner_project`
* Public discovery source for valid `owner_project`: `labels/projects_filtered.json`
* Metric scope: application-level metrics are mostly based on smart contracts mapped to the `owner_project`
* Commercial packaging: application-level data is part of the Advanced package. More info: [growthepie data tiers](https://www.growthepie.com/sales#data-tiers)

## Key Response Sections

* `last_updated_utc`
* `metrics`
* `kpi_cards`
* `first_seen`
* `chains_by_size`
* `contracts_table`

## Example Response Excerpt

```json
{
  "last_updated_utc": "2026-03-27 05:40:34",
  "first_seen": {
    "polygon_pos": "2020-10-01",
    "ethereum": "2021-01-01",
    "optimism": "2021-11-11",
    "arbitrum": "2022-04-18",
    "base": "2023-07-29"
  },
  "metrics": {
    "txcount": {
      "metric_name": "Transaction Count",
      "avg": true,
      "over_time": {
        "arbitrum": {
          "daily": {
            "types": ["unix", "value"]
          }
        }
      }
    }
  },
  "contracts_table": {
    "7d": {
      "types": []
    }
  }
}
```

## When To Use apps/details/{owner\_project}.json

* You need app-level metrics for one project
* You want chain-by-chain activity for one app
* You need first-seen dates or contract-level tables for one project
* You have already confirmed that the `owner_project` exists in `labels/projects_filtered.json`
* You want metrics that are derived mostly from smart contracts mapped to a project rather than from whole-chain activity

## When Not To Use apps/details/{owner\_project}.json

* You need the full list of valid projects before choosing one project
* You need flat chain-level exports instead of a project detail object

## Caveats

* This endpoint exists for `owner_project` values with mapped contract activity.
* The app detail endpoint is only available for `owner_project` values in `labels/projects_filtered.json`, not for every project in `labels/projects.json`.
* The metric set can vary by project. The `uniswap` example currently exposes metrics such as `txcount`, `daa`, `gas_fees`, `success_rate`, `market_cap`, `token_price`, and `token_volume`.
* Use `labels/projects_filtered.json` before generating code that assumes an app-detail endpoint exists.
* When you publish or reuse output derived from this endpoint, clearly state growthepie as the data source.
* Application metrics are not the same thing as chain metrics. If you need network-wide values for a chain, use chain endpoints keyed by `origin_key`.

## Related Pages

* [What Is owner\_project?](/core-concepts/what-is-owner-project)
* [Endpoint: labels/projects.json](/api-reference/api/labels-projects-json)
* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers)


# Metric Reference Overview

Canonical reference pages for growthepie metric\_id and metric\_key definitions.

This section defines the public growthepie metrics one by one. Each metric page answers the same questions in the same order: what the metric means, which `metric_id` and `metric_key` values are canonical, what unit the metric uses, whether hourly data exists, what the main caveats are, and when the metric is the right tool for the job.

## Canonical Metric IDs

* `app_revenue`
* `daa`
* `fdv`
* `fees`
* `market_cap`
* `profit`
* `rent_paid`
* `stables_mcap`
* `throughput`
* `tvl`
* `txcosts`
* `txcount`

## How To Read These Pages

* Use `metric_id` when you are choosing an API path such as `export/{metric}.json`.
* Use `metric_key` when you are reading raw rows returned by flat exports.
* Use `master.json.metrics.{metric_id}` for the live source of truth on supported chains and unit metadata.

## Related Pages

* [What Is metric\_key?](/core-concepts/what-is-metric-key)
* [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json)


# app\_revenue

Definition and usage guidance for the growthepie app\_revenue metric.

`app_revenue` measures App Revenue in growthepie's public metric model. Use `app_revenue` when you want app-oriented fee generation rather than chain-level fees paid by users.

## Key Facts

* Canonical `metric_id`: `app_revenue`
* Canonical `metric_key` values: `app_fees_usd`, `app_fees_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.app_revenue.supported_chains`
* Common search synonyms: app fees, app revenue

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/app_revenue.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "app_fees_usd",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 51420.89
  },
  {
    "metric_key": "app_fees_eth",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 16.74
  }
]
```

## When To Use app\_revenue

* Compare app-oriented fee generation across chains
* Separate app activity monetization from chain fee metrics

## When Not To Use app\_revenue

* You need chain-level fees paid by users
* You need project coverage metadata rather than a metric export

## Caveats

* `app_revenue` is distinct from `fees`.
* Availability still depends on per-chain support in `master.json`.

## Related Pages

* [fees](/metric-reference/metric-reference/fees)
* [Endpoint: labels/projects.json](/api-reference/api/labels-projects-json)


# daa

Definition and usage guidance for the growthepie daa metric.

`daa` measures active addresses for a covered chain. Use `daa` when you want an address-level activity proxy rather than a pure transaction count.

## Key Facts

* Canonical `metric_id`: `daa`
* Canonical `metric_key`: `daa`
* Unit: count
* Hourly detail available: yes
* Coverage: see `master.json.metrics.daa.supported_chains`
* Common search synonyms: daily active addresses, active addresses

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/daa.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "daa",
    "origin_key": "arbitrum",
    "date": "2026-01-01",
    "value": 907687.0
  }
]
```

## When To Use daa

* Compare address activity across chains
* Track user-like activity trends over time
* Complement `txcount` with an address-based signal

## When Not To Use daa

* You need exact unique users
* You need transaction volume or fee volume

## Caveats

* Address count is not the same thing as person count.
* Monthly aggregation for `daa` is not the same as summing daily values.

## Related Pages

* [txcount](/metric-reference/metric-reference/txcount)
* [Metric Interpretation Caveats](/methodology-caveats/methodology-and-caveats/metric-interpretation-caveats)


# fdv

Definition and usage guidance for the growthepie fdv metric.

`fdv` measures Fully Diluted Valuation. Use `fdv` when you want a token valuation metric rather than a usage or onchain business metric.

## Key Facts

* Canonical `metric_id`: `fdv`
* Canonical `metric_key` values: `fdv_usd`, `fdv_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.fdv.supported_chains`
* Common search synonyms: fully diluted valuation

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/fdv.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "fdv_usd",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 14500000000.0
  },
  {
    "metric_key": "fdv_eth",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 4850000.0
  }
]
```

## When To Use fdv

* Compare token valuation across covered chains
* Pair valuation analysis with onchain usage metrics

## When Not To Use fdv

* You need network activity
* You need market cap instead of fully diluted valuation

## Caveats

* `fdv` is a market metric and can move with price even when onchain usage is unchanged.

## Related Pages

* [market\_cap](/metric-reference/metric-reference/market-cap)
* [txcount](/metric-reference/metric-reference/txcount)


# fees

Definition and usage guidance for the growthepie fees metric.

`fees` is the public growthepie metric identifier for fees paid by users. In the growthepie metadata, this metric is also labeled `Revenue`, so you should treat `fees` and revenue as the same canonical public metric in API paths and docs.

## Key Facts

* Canonical `metric_id`: `fees`
* Canonical `metric_key` values: `fees_paid_usd`, `fees_paid_eth`
* Unit: USD and ETH
* Hourly detail available: yes
* Coverage: see `master.json.metrics.fees.supported_chains`
* Common search synonyms: revenue, fees paid by users

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/fees.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "fees_paid_usd",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 315245.11
  },
  {
    "metric_key": "fees_paid_eth",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 102.74
  }
]
```

## When To Use fees

* Measure the fee volume users paid on a chain
* Compare chain fee generation over time

## When Not To Use fees

* You need net profit instead of gross user-paid fees
* You need app-specific fee volume instead of chain-level fees

## Caveats

* The API path uses `fees`, while the metadata display name is `Revenue`.
* `fees` is distinct from `app_revenue`.

## Related Pages

* [app\_revenue](/metric-reference/metric-reference/app-revenue)
* [profit](/metric-reference/metric-reference/profit)


# market\_cap

Definition and usage guidance for the growthepie market\_cap metric.

`market_cap` measures market capitalization for covered chains with supported token coverage. Use `market_cap` when you want circulating-value style valuation rather than fully diluted valuation.

## Key Facts

* Canonical `metric_id`: `market_cap`
* Canonical `metric_key` values: `market_cap_usd`, `market_cap_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.market_cap.supported_chains`
* Common search synonyms: market cap

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/market_cap.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "market_cap_usd",
    "origin_key": "optimism",
    "date": "2026-03-01",
    "value": 6200000000.0
  },
  {
    "metric_key": "market_cap_eth",
    "origin_key": "optimism",
    "date": "2026-03-01",
    "value": 2070000.0
  }
]
```

## When To Use market\_cap

* Compare token market value across covered chains
* Pair market value with usage metrics such as `txcount` or `daa`

## When Not To Use market\_cap

* You need fully diluted valuation
* You need onchain activity or cost metrics

## Caveats

* `market_cap` is a market metric and can change because of price moves.

## Related Pages

* [fdv](/metric-reference/metric-reference/fdv)
* [daa](/metric-reference/metric-reference/daa)


# profit

Definition and usage guidance for the growthepie profit metric.

`profit` is the public growthepie metric identifier for Onchain Profit. Use `profit` when you want growthepie's net-like business metric rather than a gross fee series.

## Key Facts

* Canonical `metric_id`: `profit`
* Canonical `metric_key` values: `profit_usd`, `profit_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.profit.supported_chains`
* Common search synonyms: onchain profit, net revenue

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/profit.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "profit_usd",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 126430.91
  },
  {
    "metric_key": "profit_eth",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 41.22
  }
]
```

## When To Use profit

* Compare the chain business outcome after cost-sensitive adjustments
* Pair with `fees` and `rent_paid` in chain economics analysis

## When Not To Use profit

* You need gross fees paid by users
* You need transaction or address activity

## Caveats

* `profit` is a derived business metric, not a raw activity count.
* In the backend metric registry, this metric is configured with missing-date fill behavior in some derived views.

## Related Pages

* [fees](/metric-reference/metric-reference/fees)
* [rent\_paid](/metric-reference/metric-reference/rent-paid)


# rent\_paid

Definition and usage guidance for the growthepie rent\_paid metric.

`rent_paid` measures Rent Paid to L1. Use `rent_paid` when you want the cost side of a chain's relationship with the base layer rather than the gross fees paid by users.

## Key Facts

* Canonical `metric_id`: `rent_paid`
* Canonical `metric_key` values: `rent_paid_usd`, `rent_paid_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.rent_paid.supported_chains`
* Common search synonyms: L1 rent, settlement cost

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/rent_paid.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "rent_paid_usd",
    "origin_key": "optimism",
    "date": "2026-03-01",
    "value": 84521.33
  },
  {
    "metric_key": "rent_paid_eth",
    "origin_key": "optimism",
    "date": "2026-03-01",
    "value": 27.58
  }
]
```

## When To Use rent\_paid

* Compare L1-related cost burden across chains
* Pair cost-side analysis with `fees` and `profit`

## When Not To Use rent\_paid

* You need gross user-paid fees
* You need app-level revenue

## Caveats

* `rent_paid` is not a usage metric.
* In the backend metric registry, this metric is configured with missing-date fill behavior in some derived views.

## Related Pages

* [fees](/metric-reference/metric-reference/fees)
* [profit](/metric-reference/metric-reference/profit)


# stables\_mcap

Definition and usage guidance for the growthepie stables\_mcap metric.

`stables_mcap` measures stablecoin supply on a covered chain. Use `stables_mcap` when you want a stablecoin-focused value metric rather than a broader secured-value metric such as `tvl`.

## Key Facts

* Canonical `metric_id`: `stables_mcap`
* Canonical `metric_key` values: `stables_mcap`, `stables_mcap_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.stables_mcap.supported_chains`
* Common search synonyms: stablecoin market cap, stablecoin supply

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/stables_mcap.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "stables_mcap",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 3400000000.0
  },
  {
    "metric_key": "stables_mcap_eth",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 1140000.0
  }
]
```

## When To Use stables\_mcap

* Track stablecoin presence on a chain
* Compare stablecoin-denominated value across chains

## When Not To Use stables\_mcap

* You need overall secured value
* You need transaction activity or fee metrics

## Caveats

* `stables_mcap` is narrower than `tvl`.
* Currency-paired raw series can appear in both USD and ETH form.

## Related Pages

* [tvl](/metric-reference/metric-reference/tvl)
* [fees](/metric-reference/metric-reference/fees)


# throughput

Definition and usage guidance for the growthepie throughput metric.

`throughput` measures throughput using the raw series `gas_per_second`. Use `throughput` when you want a chain capacity or throughput view rather than a transaction-count view.

## Key Facts

* Canonical `metric_id`: `throughput`
* Canonical `metric_key`: `gas_per_second`
* Unit: `Mgas/s`
* Hourly detail available: yes
* Coverage: see `master.json.metrics.throughput.supported_chains`
* Common search synonyms: gas per second, throughput

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/throughput.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "gas_per_second",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 5.72
  }
]
```

## When To Use throughput

* Compare processing throughput across chains
* Track throughput changes over time

## When Not To Use throughput

* You need transaction count instead of gas throughput
* You need fee cost or value metrics

## Caveats

* `throughput` is not the same thing as `txcount`.
* The unit is `Mgas/s`, not raw transaction count.

## Related Pages

* [txcount](/metric-reference/metric-reference/txcount)
* [txcosts](/metric-reference/metric-reference/txcosts)


# tvl

Definition and usage guidance for the growthepie tvl metric.

`tvl` is the growthepie metric identifier for Total Value Secured. Use `tvl` when you want the amount of value secured on a covered chain, expressed through paired USD and ETH raw series.

## Key Facts

* Canonical `metric_id`: `tvl`
* Canonical `metric_key` values: `tvl`, `tvl_eth`
* Unit: USD and ETH
* Hourly detail available: no
* Coverage: see `master.json.metrics.tvl.supported_chains`
* Common search synonyms: TVL, TVS, total value secured

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/tvl.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "tvl",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 2450000000.0
  },
  {
    "metric_key": "tvl_eth",
    "origin_key": "arbitrum",
    "date": "2026-03-01",
    "value": 820000.0
  }
]
```

## When To Use tvl

* Compare secured value across chains
* Track value concentration over time

## When Not To Use tvl

* You need transaction activity
* You need stablecoin-only coverage instead of broader secured value

## Caveats

* `tvl` and `tvl_eth` are separate raw series.
* Value metrics can move because of price changes, not just capital movement.

## Related Pages

* [stables\_mcap](/metric-reference/metric-reference/stables-mcap)
* [market\_cap](/metric-reference/metric-reference/market-cap)


# txcosts

Definition and usage guidance for the growthepie txcosts metric.

`txcosts` measures transaction costs using median fee series. Use `txcosts` when you want a cost-per-transaction style metric rather than total fees paid.

## Key Facts

* Canonical `metric_id`: `txcosts`
* Canonical `metric_key` values: `txcosts_median_usd`, `txcosts_median_eth`
* Unit: USD and ETH
* Hourly detail available: yes
* Coverage: see `master.json.metrics.txcosts.supported_chains`
* Common search synonyms: median fee, transaction cost

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/txcosts.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "txcosts_median_usd",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 0.0041
  },
  {
    "metric_key": "txcosts_median_eth",
    "origin_key": "base",
    "date": "2026-03-01",
    "value": 0.0000013
  }
]
```

## When To Use txcosts

* Compare typical transaction cost across chains
* Track fee affordability trends over time

## When Not To Use txcosts

* You need total fees paid instead of typical per-transaction cost
* You need transaction volume

## Caveats

* `txcosts` is a median-style cost metric, not total cost.
* Aggregate comparisons across chains use a weighted-mean style aggregation in growthepie metadata.

## Related Pages

* [fees](/metric-reference/metric-reference/fees)
* [throughput](/metric-reference/metric-reference/throughput)
* [Endpoint: fees/table.json](/api-reference/api/fees-table-json)


# txcount

Definition and usage guidance for the growthepie txcount metric.

`txcount` measures transaction count for a covered chain. Use `txcount` when you want to compare how many transactions a chain processed over time or across chains.

## Key Facts

* Canonical `metric_id`: `txcount`
* Canonical `metric_key`: `txcount`
* Unit: count
* Hourly detail available: yes
* Coverage: see `master.json.metrics.txcount.supported_chains`
* Common search synonyms: transaction count, daily transactions

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/txcount.json
```

## Example Response Excerpt

```json
[
  {
    "metric_key": "txcount",
    "origin_key": "arbitrum",
    "date": "2021-05-29",
    "value": 9.0
  }
]
```

## When To Use txcount

* Compare chain activity over time
* Rank chains by raw transaction volume
* Build a daily or hourly activity chart

## When Not To Use txcount

* You need a user proxy instead of an activity count
* You need fee or cost information

## Caveats

* `txcount` counts transactions, not unique users.
* `txcount` does not normalize for transaction complexity or gas usage.

## Related Pages

* [daa](/metric-reference/metric-reference/daa)
* [throughput](/metric-reference/metric-reference/throughput)


# Coverage Overview

Reference for which chains, projects, and data availability layers are covered by growthepie.

growthepie coverage changes over time, so the live source of truth is always the API itself. Use `master.json` for chain and DA coverage, and use `labels/projects.json` for project coverage.

## Key Facts

* Live chain coverage source: `master.json.chains`
* Live DA coverage source: `master.json.da_layers` and `master.json.da_metrics`
* Live project coverage source: `labels/projects.json`

## Related Pages

* [Supported Chains And origin\_key](/entity-coverage-reference/entity-coverage-reference/supported-chains-and-origin-key)
* [Projects And owner\_project](/entity-coverage-reference/entity-coverage-reference/projects-and-owner-project)
* [Data Availability Layers And DA Metrics](/entity-coverage-reference/entity-coverage-reference/data-availability-layers-and-da-metrics)


# Supported Chains And origin\_key

Canonical chain coverage reference for growthepie origin\_key values.

The canonical live list of covered chains is `master.json.chains`. During this docs refresh on March 27, 2026, the live API exposed 31 chain entries, including aggregate entities such as `all_l2s` and `multiple`.

## Current Chain Entries

| origin\_key     | Name             | chain\_type |
| --------------- | ---------------- | ----------- |
| `ethereum`      | Ethereum Mainnet | `l1`        |
| `all_l2s`       | All L2s          | `others`    |
| `arbitrum`      | Arbitrum One     | `rollup`    |
| `arbitrum_nova` | Arbitrum Nova    | `others`    |
| `base`          | Base Chain       | `rollup`    |
| `celo`          | Celo             | `others`    |
| `fraxtal`       | Fraxtal          | `others`    |
| `gravity`       | Gravity          | `others`    |
| `ink`           | Ink              | `rollup`    |
| `linea`         | Linea            | `rollup`    |
| `lisk`          | Lisk             | `others`    |
| `loopring`      | Loopring         | `rollup`    |
| `manta`         | Manta Pacific    | `others`    |
| `mantle`        | Mantle           | `others`    |
| `megaeth`       | MegaETH          | `others`    |
| `metis`         | Metis            | `others`    |
| `mode`          | Mode Network     | `others`    |
| `optimism`      | OP Mainnet       | `rollup`    |
| `plume`         | Plume Network    | `others`    |
| `polygon_pos`   | Polygon PoS      | `others`    |
| `ronin`         | Ronin            | `others`    |
| `scroll`        | Scroll           | `rollup`    |
| `soneium`       | Soneium          | `others`    |
| `starknet`      | Starknet         | `rollup`    |
| `taiko`         | Taiko Alethia    | `others`    |
| `unichain`      | Unichain         | `rollup`    |
| `worldchain`    | World Chain      | `others`    |
| `zircuit`       | Zircuit          | `rollup`    |
| `zksync_era`    | ZKsync Era       | `rollup`    |

## Caveats

* Not every `origin_key` supports every metric.
* Aggregate entities such as `all_l2s` are useful for comparison but are not individual chains.

## Related Pages

* [What Is origin\_key?](/core-concepts/what-is-origin-key)
* [Endpoint: master.json](/api-reference/api/master-json)


# Projects And owner\_project

Reference for growthepie project coverage and owner\_project identifiers.

`owner_project` is the canonical project identifier exposed by `labels/projects.json`. Use `owner_project` when you need to map project metadata, join project coverage with downstream analysis workflows, or fetch a project detail response from `apps/details/{owner_project}.json`.

`owner_project` is the application-level scope in growthepie. Application metrics are mostly based on smart contracts mapped to that project, while chain metrics describe whole-network activity for an `origin_key`.

## Key Facts

* Canonical source: `https://api.growthepie.com/v1/labels/projects.json`
* App-detail discovery source: `https://api.growthepie.com/v1/labels/projects_filtered.json`
* Last verified in this docs refresh: March 27, 2026
* Live project count in `projects.json` at that time: 6,650
* Live project count in `projects_filtered.json` at that time: 757
* Core fields: `owner_project`, `display_name`, `description`, `website`, `main_category`, `sub_category`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/labels/projects.json
```

## Example Use

Use `labels/projects.json` when you need to answer questions such as:

* Which `owner_project` values are covered?
* What human-readable name matches a given `owner_project`?
* Which categories and subcategories are assigned to a project?
* Which project detail JSON path should I call for a given app?

Use `labels/projects_filtered.json` when you need to answer questions such as:

* Which `owner_project` values currently have actual datapoints such as `txcount`?
* Which `owner_project` values can be used with `apps/details/{owner_project}.json`?

## Caveats

* The payload is a typed table, not a list of JSON objects.
* Coverage size changes over time, so prefer the live endpoint over hardcoded lists.
* `projects.json` includes all projects with metadata.
* `projects_filtered.json` is the subset with actual datapoints and is the correct discovery list for app-detail endpoints.
* Application-level project detail belongs to the Advanced package. Chain-level coverage belongs to the Basic package. More info: [growthepie data tiers](https://www.growthepie.com/sales#data-tiers)

## Related Pages

* [What Is owner\_project?](/core-concepts/what-is-owner-project)
* [Endpoint: labels/projects.json](/api-reference/api/labels-projects-json)
* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)
* [Chain vs App vs Ecosystem Metrics](/core-concepts/chain-vs-app-vs-ecosystem-metrics)
* [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers)


# Data Availability Layers And DA Metrics

Reference for growthepie data availability layer coverage and DA metric identifiers.

growthepie exposes data availability layer coverage through `master.json.da_layers` and data availability metric coverage through `master.json.da_metrics`. During this docs refresh on March 27, 2026, the live API exposed four DA layers and five DA metrics.

## Current DA Layers

* `da_celestia`: Celestia
* `da_eigenda`: EigenDA
* `da_ethereum_blobs`: Ethereum Blobs
* `da_ethereum_calldata`: Ethereum Calldata

## Current DA Metrics

* `blob_count`
* `blob_producers`
* `data_posted`
* `fees_paid`
* `fees_per_mbyte`

## Related Pages

* [Endpoint: master.json](/api-reference/api/master-json)
* [Coverage And Exclusions](/methodology-caveats/methodology-and-caveats/coverage-and-exclusions)


# Recipes Overview

Practical recipes for common growthepie API tasks.

This section turns the API reference into concrete tasks. Each recipe is complete and runnable, and each recipe uses real public endpoints instead of pseudo-code.

## Common Tasks

* Fetch one metric export
* Load daily exports into pandas
* Fetch data in Python or JavaScript
* Compare multiple chains over time
* Plot a time series
* Export to CSV

## Related Pages

* [Quickstart](/getting-started/getting-started/quickstart)
* [API Overview](/api-reference/api)


# Fetch A Metric In curl

Use curl to fetch a growthepie metric export and filter it locally.

This recipe fetches one full metric export with `curl` and filters it with `jq`. Use this recipe when you want a fast shell-based workflow without writing a full script.

## Example

```bash
curl -s https://api.growthepie.com/v1/export/txcount.json \
  | jq '[.[] | select(.origin_key == "arbitrum")] | .[0:5]'
```

## What This Does

* Downloads the public `txcount` export
* Filters rows to one `origin_key`
* Prints the first five matching rows

## Related Pages

* [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json)


# Fetch growthepie Data In Python

Use Python requests to fetch growthepie data safely.

This recipe fetches `fundamentals.json` in Python and prints a few filtered rows. Use this recipe when you want a lightweight script without adding pandas immediately.

## Example

```python
import requests

url = "https://api.growthepie.com/v1/fundamentals.json"
response = requests.get(url, timeout=30)
response.raise_for_status()

rows = response.json()
filtered = [
    row for row in rows
    if row["origin_key"] == "arbitrum" and row["metric_key"] == "txcount"
]

print(filtered[:5])
```

## Related Pages

* [Load Into pandas](/recipes-tutorials/recipes/load-into-pandas)
* [Endpoint: fundamentals.json](/api-reference/api/fundamentals-json)


# Fetch growthepie Data In JS Or TS

Use JavaScript or TypeScript fetch to load growthepie data.

This recipe fetches `master.json` and prints the supported metrics for `arbitrum`. Use this recipe when you want discovery metadata inside a browser app, Node.js tool, or TypeScript project.

## Example

```ts
const url = "https://api.growthepie.com/v1/master.json";

const response = await fetch(url);
if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const master = await response.json();
console.log(master.chains.arbitrum.supported_metrics);
```

## Related Pages

* [Endpoint: master.json](/api-reference/api/master-json)
* [Choose The Right Endpoint](/getting-started/getting-started/choose-the-right-endpoint)


# Load Into pandas

Load growthepie fundamentals data into a pandas DataFrame.

This recipe loads `fundamentals.json` into pandas and filters it to one chain and one metric. Use this recipe when you want a notebook-friendly workflow.

## Example

```python
import pandas as pd
import requests

url = "https://api.growthepie.com/v1/fundamentals.json"
response = requests.get(url, timeout=30)
response.raise_for_status()

df = pd.DataFrame(response.json())
df["date"] = pd.to_datetime(df["date"])

subset = df[
    (df["origin_key"] == "arbitrum") &
    (df["metric_key"] == "txcount")
].sort_values("date")

print(subset.tail())
```

## Related Pages

* [Compare Chains Over Time](/recipes-tutorials/recipes/compare-chains-over-time)
* [Plot A Timeseries](/recipes-tutorials/recipes/plot-a-timeseries)


# Compare Chains Over Time

Compare multiple chains over time with growthepie exports.

This recipe compares transaction count across several chains using the public `txcount` export. Use this recipe when you want a normalized notebook workflow for multi-chain comparisons.

## Example

```python
import pandas as pd
import requests

url = "https://api.growthepie.com/v1/export/txcount.json"
rows = requests.get(url, timeout=30).json()

df = pd.DataFrame(rows)
df["date"] = pd.to_datetime(df["date"])

chains = ["arbitrum", "base", "optimism"]
subset = df[df["origin_key"].isin(chains)]

pivot = subset.pivot_table(
    index="date",
    columns="origin_key",
    values="value",
    aggfunc="sum"
).sort_index()

print(pivot.tail())
```

## Related Pages

* [txcount](/metric-reference/metric-reference/txcount)
* [Plot A Timeseries](/recipes-tutorials/recipes/plot-a-timeseries)


# Plot A Timeseries

Plot a growthepie time series with pandas and matplotlib.

This recipe plots a time series for `txcount` on `arbitrum`. Use this recipe when you want a notebook-ready chart from the public exports.

## Example

```python
import matplotlib.pyplot as plt
import pandas as pd
import requests

url = "https://api.growthepie.com/v1/export/txcount.json"
rows = requests.get(url, timeout=30).json()

df = pd.DataFrame(rows)
df["date"] = pd.to_datetime(df["date"])

series = df[df["origin_key"] == "arbitrum"].sort_values("date")

series.plot(x="date", y="value", figsize=(12, 4), title="Arbitrum Transaction Count")
plt.ylabel("txcount")
plt.tight_layout()
plt.show()
```

## Related Pages

* [Load Into pandas](/recipes-tutorials/recipes/load-into-pandas)
* [txcount](/metric-reference/metric-reference/txcount)


# Export To CSV

Export growthepie data to CSV for spreadsheet or notebook workflows.

This recipe downloads one metric export and writes it to CSV. Use this recipe when you want a local file for spreadsheet workflows, versioned data snapshots, or notebook inputs.

## Example

```python
import csv
import requests

url = "https://api.growthepie.com/v1/export/txcount.json"
rows = requests.get(url, timeout=30).json()

with open("txcount.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["metric_key", "origin_key", "date", "value"])
    writer.writeheader()
    writer.writerows(rows)

print("Wrote txcount.csv")
```

## Related Pages

* [Fetch growthepie Data In Python](/recipes-tutorials/recipes/fetch-growthepie-data-in-python)
* [Endpoint: export/{metric}.json](/api-reference/api/export-metric-json)


# Use Cases Overview

High-intent landing pages that answer practical growthepie questions and point readers to the live platform and API.

This section is built around real developer and researcher intents. Each page answers one concrete question, links to the relevant growthepie.com experience, and shows the API endpoint that powers the answer.

## What These Pages Do

* Capture common search intents
* Route readers to the live growthepie platform
* Show the exact API path behind the answer
* Stay grounded in the public API documented on this site

## Related Pages

* [API Overview](/api-reference/api)
* [Recipes Overview](/recipes-tutorials/recipes)


# How To Compare Layer 2 Transaction Count Over Time

Compare Layer 2 transaction count over time with growthepie and the public API.

Use growthepie when you want to compare transaction activity across Layer 2s over time. The fastest path is to explore the live chart on growthepie.com and then use `export/txcount.json` or `metrics/chains/{origin_key}/txcount.json` when you need the underlying data in code.

## Explore It Live

* Live platform: <https://www.growthepie.com/fundamentals/transaction-count>

## API Paths

* Broad export: `https://api.growthepie.com/v1/export/txcount.json`
* Rich per-chain detail: `https://api.growthepie.com/v1/metrics/chains/arbitrum/txcount.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/txcount.json
```

## Real Task Example

```python
import pandas as pd
import requests

rows = requests.get("https://api.growthepie.com/v1/export/txcount.json", timeout=30).json()
df = pd.DataFrame(rows)
df["date"] = pd.to_datetime(df["date"])

chains = ["arbitrum", "base", "optimism"]
comparison = df[df["origin_key"].isin(chains)].pivot_table(
    index="date",
    columns="origin_key",
    values="value",
    aggfunc="sum",
).sort_index()

print(comparison.tail())
```

## Caveats

* `txcount` is activity count, not user count.
* Do not exceed 10 API calls per minute.

## Related Pages

* [txcount](/metric-reference/metric-reference/txcount)
* [How To Compare Base vs Arbitrum](/use-cases/use-cases/how-to-compare-base-vs-arbitrum)


# How To Compare Base vs Arbitrum

Compare Base and Arbitrum with growthepie using live dashboards and the API.

Use growthepie to compare Base and Arbitrum when you want a grounded view of activity, costs, value, and app usage. Start on the live chain pages, then use `master.json` and the metric exports to reproduce the comparison programmatically.

## Explore It Live

* Base: <https://www.growthepie.com/chains/base>
* Arbitrum: <https://www.growthepie.com/chains/arbitrum>

## API Paths

* Discovery: `https://api.growthepie.com/v1/master.json`
* Chain overview: `https://api.growthepie.com/v1/chains/base/overview.json`
* Chain overview: `https://api.growthepie.com/v1/chains/arbitrum/overview.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/chains/base/overview.json
```

## What To Compare

* `txcount` for raw activity
* `daa` for address-level activity
* `txcosts` for median transaction costs
* `stables_mcap` or `tvl` for value

## Caveats

* Different metrics answer different questions. Do not compare `txcount` and `tvl` as if they measured the same thing.
* Exclude any chain whose `deployment` or `deployment_flag` is `DEV` or `ARCHIVED`.

## Related Pages

* [How To Find Which Metrics A Chain Supports](/use-cases/use-cases/how-to-find-which-metrics-a-chain-supports)
* [How To Get Chain Overview Data For Arbitrum](/use-cases/use-cases/how-to-get-chain-overview-data-for-arbitrum)


# How To Compare Stablecoin Supply Across Chains

Compare stablecoin supply across chains with growthepie and stables\_mcap exports.

Use growthepie when you want to compare stablecoin supply across Ethereum and Layer 2s. The live platform gives you the fastest visual read, and `export/stables_mcap.json` gives you the underlying rows for notebooks and dashboards.

## Explore It Live

* Live platform: <https://www.growthepie.com/fundamentals/stablecoin-market-cap>

## API Path

* `https://api.growthepie.com/v1/export/stables_mcap.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/export/stables_mcap.json
```

## Real Task Example

```python
import pandas as pd
import requests

rows = requests.get("https://api.growthepie.com/v1/export/stables_mcap.json", timeout=30).json()
df = pd.DataFrame(rows)

usd_rows = df[df["metric_key"] == "stables_mcap"]
latest = usd_rows.sort_values("date").groupby("origin_key").tail(1)
print(latest[["origin_key", "date", "value"]].sort_values("value", ascending=False).head(10))
```

## Caveats

* `stables_mcap` is narrower than `tvl`.
* Currency-paired raw series exist in both USD and ETH form.

## Related Pages

* [stables\_mcap](/metric-reference/metric-reference/stables-mcap)
* [tvl](/metric-reference/metric-reference/tvl)


# How To Find Which Metrics A Chain Supports

Find which metrics a chain supports in growthepie before generating queries or code.

Use `master.json` to discover which metrics a chain supports before you query exports or generate code. This avoids invalid assumptions and lets you exclude unsupported combinations up front.

## Explore It Live

* Live platform: <https://www.growthepie.com/>

## API Path

* `https://api.growthepie.com/v1/master.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/master.json
```

## Real Task Example

```python
import requests

master = requests.get("https://api.growthepie.com/v1/master.json", timeout=30).json()
print(master["chains"]["arbitrum"]["supported_metrics"])
```

## Caveats

* Check `deployment` or `deployment_flag` as well as `supported_metrics`.
* Use the live metadata instead of hardcoding support tables.

## Related Pages

* [Endpoint: master.json](/api-reference/api/master-json)
* [How To Identify Chains With Stale Data](https://github.com/growthepie/wiki/blob/master/gitbook/use-cases/how-to-identify-chains-with-stale-data.md)


# How To Get Chain Overview Data For Arbitrum

Get the Arbitrum chain overview from growthepie and understand what it includes.

Use the chain overview endpoint when you want the growthepie summary view for Arbitrum in one request. This is the right endpoint for highlights, rankings, KPI cards, achievements, and ecosystem context.

## Explore It Live

* Live platform: <https://www.growthepie.com/chains/arbitrum>

## API Path

* `https://api.growthepie.com/v1/chains/arbitrum/overview.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/chains/arbitrum/overview.json
```

## What You Get

* `highlights`
* `events`
* `ranking`
* `kpi_cards`
* `achievements`
* `ecosystem`

## Caveats

* This is an overview payload, not a flat analytics export.
* Use metric detail endpoints when you need richer per-metric time series.

## Related Pages

* [Endpoint: chains/{origin\_key}/overview.json](/api-reference/api/chain-overview-json)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)


# How To Identify Chains With Stale Data


# How To Use owner\_project In The growthepie API

Use owner\_project correctly in growthepie project coverage and app-detail endpoints.

Use `owner_project` as the canonical project identifier in growthepie app-level endpoints. Start with `labels/projects.json` for the full metadata universe, then use `labels/projects_filtered.json` to find which `owner_project` values have actual datapoints and app-detail coverage.

## Explore It Live

* Live platform: <https://www.growthepie.com/>

## API Paths

* Full metadata: `https://api.growthepie.com/v1/labels/projects.json`
* Filtered subset: `https://api.growthepie.com/v1/labels/projects_filtered.json`
* App detail: `https://api.growthepie.com/v1/apps/details/uniswap.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/labels/projects_filtered.json
```

## Caveats

* `owner_project` is not the same thing as `origin_key`.
* Not every `owner_project` in `projects.json` has an app-detail endpoint.

## Related Pages

* [What Is owner\_project?](/core-concepts/what-is-owner-project)
* [How To Use projects\_filtered.json](/use-cases/use-cases/how-to-use-projects-filtered-json)


# How To Use projects\_filtered.json

Use projects\_filtered.json to find which projects have real datapoints and app-detail coverage.

Use `labels/projects_filtered.json` when you need the subset of projects that have actual datapoints such as `txcount`. This is the correct discovery source for `apps/details/{owner_project}.json`.

## Explore It Live

* Live platform: <https://www.growthepie.com/>

## API Path

* `https://api.growthepie.com/v1/labels/projects_filtered.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/labels/projects_filtered.json
```

## Why It Matters

* `projects.json` includes all projects with metadata
* `projects_filtered.json` includes only projects with real datapoints
* app-detail endpoints are only available for `owner_project` values in `projects_filtered.json`

## Real Task Example

```python
import requests

filtered = requests.get("https://api.growthepie.com/v1/labels/projects_filtered.json", timeout=30).json()
print(filtered["data"]["types"])
print(filtered["data"]["data"][0])
```

## Related Pages

* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [How To Fetch App-Level Metrics For Uniswap](/use-cases/use-cases/how-to-fetch-app-level-metrics-for-uniswap)


# How To Fetch App-Level Metrics For Uniswap

Fetch app-level metrics for Uniswap with growthepie and the app detail endpoint.

Use `apps/details/uniswap.json` when you want a project-level response for Uniswap with metrics, KPI cards, first-seen dates, and contract tables. This is the fastest public path to a grounded app-level payload in the growthepie API.

## Explore It Live

* Live platform: <https://www.growthepie.com/>

## API Path

* `https://api.growthepie.com/v1/apps/details/uniswap.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/apps/details/uniswap.json
```

## Example Response Shape

```json
{
  "last_updated_utc": "2026-03-27 05:40:34",
  "metrics": {
    "txcount": {
      "metric_name": "Transaction Count",
      "avg": true
    }
  },
  "first_seen": {
    "ethereum": "2021-01-01"
  }
}
```

## Caveats

* Validate `uniswap` against `labels/projects_filtered.json` before assuming the endpoint exists.
* The metric set can vary by project.

## Related Pages

* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)
* [How To Use projects\_filtered.json](/use-cases/use-cases/how-to-use-projects-filtered-json)


# How To Find Top Apps On A Chain

Find top apps on a chain with growthepie chain overview data and the live platform.

Use growthepie chain pages and chain overview JSON when you want to see which apps are active on a chain. The live platform is the quickest way to inspect the result, and the chain overview endpoint gives you a structured ecosystem payload you can use in code.

## Explore It Live

* Arbitrum: <https://www.growthepie.com/chains/arbitrum>
* Base: <https://www.growthepie.com/chains/base>

## API Path

* `https://api.growthepie.com/v1/chains/arbitrum/overview.json`

## Example Request

```bash
curl -s https://api.growthepie.com/v1/chains/arbitrum/overview.json
```

## What To Look For

* `data.ecosystem.active_apps`
* `data.ecosystem.apps`

## Caveats

* This endpoint summarizes ecosystem context. It is not a full app directory export.
* Use `labels/projects.json` or `labels/projects_filtered.json` when you need broader project discovery.

## Related Pages

* [Projects And owner\_project](/entity-coverage-reference/entity-coverage-reference/projects-and-owner-project)
* [Endpoint: chains/{origin\_key}/overview.json](/api-reference/api/chain-overview-json)


# Methodology Overview

Methodology, interpretation, and trust guidance for growthepie data consumers.

This section explains how to interpret growthepie outputs safely. It focuses on coverage, freshness, unit handling, caveats, and trust signals that help both humans and AI systems cite the right explanation for a metric.

## Related Pages

* [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers)
* [Freshness And Update Cadence](/methodology-caveats/methodology-and-caveats/freshness-and-update-cadence)
* [Coverage And Exclusions](/methodology-caveats/methodology-and-caveats/coverage-and-exclusions)
* [Metric Interpretation Caveats](/methodology-caveats/methodology-and-caveats/metric-interpretation-caveats)
* [Data Quality And Trust Signals](/methodology-caveats/methodology-and-caveats/data-quality-and-trust-signals)


# Data And API Terms

Data and API terms, attribution guidance, fair-use guidance, and package-level coverage notes for growthepie data.

Last updated: June 2, 2026.

These Data and API Terms apply to public growthepie data, chart exports, CSV downloads, public API outputs, and other datasets published by growthepie unless a more specific notice says otherwise.

These terms do not replace any separate agreement we may have with you, and they do not grant rights in third-party material, trademarks, logos, brand assets, or data that is clearly governed by another source or license.

## Open Use With Attribution

Unless otherwise stated, growthepie data is copyright or database-right protected material of orbal GmbH / growthepie where protectable, and may be used, shared, and adapted under the Creative Commons Attribution 4.0 International license: <https://creativecommons.org/licenses/by/4.0/>.

You may use the data for research, journalism, dashboards, applications, reports, models, and commercial or non-commercial products, provided that you give appropriate credit and do not imply that growthepie endorses you or your use.

Preferred attribution:

* Source: growthepie, <https://www.growthepie.com>.
* For chart screenshots or reports, include Source: growthepie near the chart or in the source notes.
* For API-backed products, include a source note in your documentation, data source list, footer, or another reasonable location.
* Where practical, link to the relevant growthepie page, chart, API endpoint, or <https://www.growthepie.com>.
* If you modify, transform, or combine the data, make that clear where it matters for interpretation.

## Third-Party And Upstream Sources

growthepie combines public blockchain data, own analysis, and selected third-party or upstream data sources. Some metrics, labels, or datasets may include source-specific terms, attribution requirements, or restrictions.

If a chart, API response, documentation page, or source list names another provider, you are responsible for respecting that provider's applicable terms in addition to these terms.

## API Access And Fair Use

Public API access is provided to support open research, builders, ecosystem analysis, and community tools. We may apply rate limits, caching, access controls, or other technical measures to keep the service reliable.

Do not use the API or website in a way that degrades availability, bypasses limits, probes security, overwhelms infrastructure, or misrepresents request origin. For high-volume, commercial, or production-critical use, contact us before relying on the service.

## No Warranty

Data is provided as-is and as-available. It may be incomplete, delayed, inaccurate, changed, reclassified, or removed. We do not guarantee uninterrupted API availability, exact historical continuity, or suitability for a specific purpose.

growthepie is an analytics and educational platform. Nothing on the website, in chart exports, or in API data is financial, investment, legal, tax, or professional advice.

## No Endorsement

Attribution to growthepie does not mean that growthepie sponsors, approves, verifies, or endorses your work, product, analysis, conclusions, or organization.

## Changes

We may update these Data and API Terms when our datasets, API, licensing approach, upstream sources, or legal requirements change. The date at the top shows when these terms were last updated.

Questions about data reuse, attribution, high-volume API use, or commercial partnerships can be sent to <matthias@orbal-analytics.com>.

## Coverage And Package Notes

* Data is only available for chains that work with growthepie.
* Chain-level data is part of the Basic package.
* Application-level data is part of the Advanced package.
* Commercial packaging details: [growthepie data tiers](https://www.growthepie.com/sales#data-tiers)
* The API is currently public, but growthepie may change access, packaging, or authentication requirements in the future.

## How To Think About Coverage

* `master.json` is the canonical source for chain and metric coverage.
* `labels/projects.json` is the broad metadata universe for projects.
* `labels/projects_filtered.json` is the subset of `owner_project` values with real datapoints such as `txcount`.
* `apps/details/{owner_project}.json` is only available for `owner_project` values in `labels/projects_filtered.json`.

## FAQ

### Do I need to attribute growthepie?

Yes. Preferred attribution is: Source: growthepie, <https://www.growthepie.com>.

### Can I use growthepie for research?

Yes. You may use growthepie data for research, journalism, dashboards, applications, reports, models, and commercial or non-commercial products, provided that you follow these terms.

### Is data available for every chain?

No. Data is only available for chains that work with growthepie. Use `master.json` to verify live chain coverage before building against an assumption.

### Which package includes app-level data?

Application-level data is part of the Advanced package. Chain-level data is part of the Basic package. The current package page is [growthepie data tiers](https://www.growthepie.com/sales#data-tiers).

### Will the API always remain public?

Not necessarily. The API is currently public, but growthepie may change access or authentication requirements in the future.

## Related Pages

* [What Is growthepie?](/core-concepts/what-is-growthepie)
* [API Overview](/api-reference/api)
* [Endpoint: master.json](/api-reference/api/master-json)
* [Endpoint: labels/projects\_filtered.json](/api-reference/api/labels-projects-filtered-json)
* [Endpoint: apps/details/{owner\_project}.json](/api-reference/api/app-detail-json)


# Freshness And Update Cadence

How to understand data freshness and update cadence in growthepie.

growthepie exposes freshness in two main ways. Rich endpoints expose `last_updated_utc`, while flat daily exports expose the newest available `date` row.

## Key Facts

* `master.json` exposes `last_updated_utc`
* Rich chain and metric detail endpoints expose `last_updated_utc`
* App detail endpoints expose `last_updated_utc`
* `fundamentals.json` is a rolling 90-day daily export
* Hourly detail exists only for metrics marked `hourly_available: true` in `master.json`

## Practical Guidance

* Read `last_updated_utc` before caching a rich endpoint
* Inspect the most recent `date` before assuming a flat export includes the current day
* Do not assume every metric has hourly detail

## Related Pages

* [Time Granularity, Freshness, And Update Cadence](/core-concepts/time-granularity-freshness-and-update-cadence)
* [Endpoint: metrics/chains/{origin\_key}/{metric\_id}.json](/api-reference/api/metric-detail-json)


# Coverage And Exclusions

Coverage rules and exclusions in growthepie data.

Coverage in growthepie is metric-specific and chain-specific. A chain can be present in `master.json` but still exclude a specific metric, so consumers should always check both the chain coverage and the metric coverage metadata.

## Key Facts

* Check `master.json.chains.{origin_key}.supported_metrics`
* Check `master.json.metrics.{metric_id}.supported_chains`
* Exclude chains whose `deployment` is `DEV` or `ARCHIVED`
* The live API changes over time, so prefer metadata over hardcoded lists

## Practical Guidance

* Validate `origin_key` before querying a metric detail endpoint
* Validate `metric_id` before generating API code or client stubs
* Treat legacy or inaccessible endpoints as unsupported until verified publicly

## Related Pages

* [Supported Chains And origin\_key](/entity-coverage-reference/entity-coverage-reference/supported-chains-and-origin-key)
* [Endpoint: master.json](/api-reference/api/master-json)


# Metric Interpretation Caveats

Common metric interpretation caveats for growthepie data.

Metrics answer specific questions and can be misread if used outside their intended scope. This page collects the most important interpretation caveats in one place.

## Common Caveats

* `daa` is an address-level signal, not a person-level user count.
* `txcount` is an activity count, not a throughput or complexity measure.
* `txcosts` is a median transaction cost metric, not total fees paid.
* `fees` is distinct from `app_revenue`.
* `market_cap` and `fdv` are market metrics and can move with token price rather than onchain usage.
* Value metrics such as `tvl` and `stables_mcap` should not be treated as direct activity metrics.

## Related Pages

* [daa](/metric-reference/metric-reference/daa)
* [txcount](/metric-reference/metric-reference/txcount)
* [txcosts](/metric-reference/metric-reference/txcosts)


# Data Quality And Trust Signals

Trust signals and source-of-truth guidance for growthepie documentation and data.

This docs set is designed so both humans and AI systems can cite definitive explanations. The strongest trust signals in growthepie are the live metadata index, the explicit `last_updated_utc` fields in richer endpoints, the consistent public terminology, and the alignment between docs and backend source-of-truth artifacts.

## Trust Signals

* `master.json` exposes canonical metadata for chains, metrics, units, and coverage
* Rich public endpoints expose `last_updated_utc`
* Docs use consistent terms such as `origin_key`, `metric_key`, `value`, and `date`
* Metric definitions are aligned to the growthepie backend metric registry
* This docs pass documents only verified public endpoints
* The repo now includes `llms.txt`, `llms-full.txt`, `public-api-catalog.json`, and `metric-catalog.json` as machine-readable discovery helpers
* Usage guidance is explicit: attribute growthepie as the data source and check coverage before assuming a chain or app is available

## Related Pages

* [Endpoint: master.json](/api-reference/api/master-json)
* [AI Validation Checklist](/methodology-caveats/methodology-and-caveats/ai-validation-checklist)
* [Data And API Terms](/methodology-caveats/methodology-and-caveats/usage-rules-and-data-tiers)


# AI Validation Checklist

Benchmark questions and a manual checklist for validating AI-friendly growthepie docs.

Use these questions to test whether the docs are easy for both humans and AI systems to retrieve, quote, and use correctly.

## Benchmark Questions

1. What is growthepie?
2. What is `origin_key`?
3. What is `owner_project`?
4. What is `metric_key`?
5. What is the difference between `metric_id` and `metric_key`?
6. Which endpoint should I call first to discover supported chains?
7. What does `master.json` return?
8. What does `fundamentals.json` return?
9. Is `fundamentals.json` full history?
10. How do I fetch `txcount` for one chain?
11. How do I fetch the full `txcount` export across chains?
12. How do I compare multiple chains over time?
13. How do I load growthepie data into pandas?
14. How do I fetch growthepie data in JavaScript?
15. What does `daa` mean?
16. What does `txcosts` mean?
17. What is the difference between `fees` and `app_revenue`?
18. What units does `throughput` use?
19. Which chains support `tvl`?
20. Which data availability layers are covered?
21. Which endpoint exposes project coverage?
22. What is the difference between `projects.json` and `projects_filtered.json`?
23. Which endpoint exposes app detail for one `owner_project`?
24. Which `owner_project` values can be used with `apps/details/{owner_project}.json`?
25. What rate limit should AI agents follow?
26. Which chains should be excluded because `deployment` or `deployment_flag` is `DEV` or `ARCHIVED`?
27. Which endpoints expose `last_updated_utc`?
28. Which metrics have hourly detail?
29. Are any public endpoints deprecated or legacy?
30. How should I attribute growthepie when I use the data?
31. Is growthepie research use encouraged?
32. Which package includes chain-level data and which package includes app-level data?

## Manual Validation Checklist

* The page answers its main question directly in the first paragraph.
* The page defines the canonical terms explicitly.
* The page includes at least one runnable example when the topic is procedural.
* The page includes caveats when the topic can be misinterpreted.
* The page is linked from `SUMMARY.md`.
* The page is text-first and does not depend on screenshots to explain the concept.
* The page uses consistent names such as `origin_key`, `metric_key`, `value`, and `date`.
* The page points to a source-of-truth artifact or endpoint when appropriate.


# Changelog Overview

Changelog and deprecation notes for the growthepie docs and public API surface documented here.

This section records meaningful docs and API-surface notes that help consumers understand what changed, what is considered legacy, and which explanations are now canonical.

## Related Pages

* [2026 Docs IA Overhaul](/changelog-deprecations/changelog-and-deprecations/2026-03-docs-ia-overhaul)
* [Deprecations And Legacy Endpoints](/changelog-deprecations/changelog-and-deprecations/deprecations-and-legacy-endpoints)


# 2026 Docs IA Overhaul

Summary of the March 2026 growthepie docs IA overhaul.

On March 27, 2026, the growthepie docs were restructured around developer intent and machine readability. The old broad API page was replaced with single-purpose pages for concepts, endpoints, metrics, coverage, recipes, methodology, and deprecations.

## What Changed

* Added a task-oriented docs IA
* Added endpoint-specific reference pages
* Added metric-specific reference pages
* Added runnable curl, Python, JS/TS, pandas, comparison, plotting, and CSV recipes
* Added AI-oriented discovery and validation files such as `llms.txt`, `llms-full.txt`, and lightweight JSON catalogs
* Removed the Spanish translation from this docs repo

## Related Pages

* [AI Validation Checklist](/methodology-caveats/methodology-and-caveats/ai-validation-checklist)
* [Deprecations And Legacy Endpoints](/changelog-deprecations/changelog-and-deprecations/deprecations-and-legacy-endpoints)


# Deprecations And Legacy Endpoints

Deprecation notes and legacy endpoint guidance for growthepie docs consumers.

This docs set focuses on public endpoints that were verified during the March 27, 2026 refresh. Some paths or concepts still appear in older docs or backend code, but they should not be treated as stable public contracts unless they are documented here and publicly accessible.

## Current Guidance

* Use `labels/projects.json` for project coverage.
* Use the endpoint pages in this docs set as the public API contract.
* Treat legacy contracts labeling guidance as superseded by the labels-oriented workflow.

## Legacy Notes

* The legacy `contracts` endpoint is not documented as a stable public endpoint in this refresh.
* Some richer internal-looking paths exist in backend code but were not publicly accessible during this refresh.
* UI naming can still use `Revenue`, but the canonical public metric path is `fees`.

## Related Pages

* [Endpoint: labels/projects.json](/api-reference/api/labels-projects-json)
* [fees](/metric-reference/metric-reference/fees)