> ## Documentation Index
> Fetch the complete documentation index at: https://docs.moralis.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Data Feeds vs. the Legacy API

> How results from Moralis Data Feeds compare to a legacy Web3 API endpoint, what comes through exactly, what you calculate, and what you add yourself.

A legacy Moralis Web3 API endpoint hands you a single, **pre-packaged, enriched response**. Data Feeds give you
the **decoded onchain dataset that produces it**, which is exactly what lets you own the data and query it
freely. Migrating means thinking in terms of that dataset rather than one fixed response. This page explains
what to expect in general; each migration guide then says precisely how it applies to that endpoint.

## The one idea

> The legacy endpoint is a *finished dish*. A Data Feed is the *ingredients*, the same onchain facts, plus
> live prices, ready for you to plate however you like (or let a recipe plate them for you).

That's a feature, not a compromise: you get the underlying data, in real time, with no per-call limits and full
control over shape, storage, and queries.

## How values compare

Every migration guide classifies each field into one of these, so there are no surprises:

| Class                | What it means                                                                                                                                                       | Examples                                                                   |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
| **Exact**            | Comes straight from the chain, identical to the endpoint                                                                                                            | balances, transfers, token name/symbol/decimals, supply                    |
| **Calculated**       | Computed from the feed (often from live DEX trades). Tracks the endpoint closely; compare with a small **tolerance** rather than expecting penny-for-penny equality | USD price, USD value, portfolio %, 24-hour change                          |
| **Yours to control** | The feed gives you everything; you apply your own rules. A gain in control, not a gap                                                                               | spam/dust filtering, which rows count as a "holding"                       |
| **Add yourself**     | Off-chain signals that aren't part of onchain data, so they aren't in the feed                                                                                      | token **logo**/thumbnail, **spam**/**verified** labels, **security score** |

## Why these differences exist

* **Prices come from real onchain trades.** Data Feeds derive USD values from DEX activity in the data lake, so
  they're live and verifiable, and may differ slightly from the legacy pricing engine. A token that hasn't
  traded recently may not have a price yet.
* **Off-chain signals live off-chain.** Logos, spam/verification labels, and security scores are curation Moralis
  layers on top of the chain. They aren't onchain facts, so they aren't in a feed. Bring your own source (e.g. a
  public token list), or layer them in alongside your Data Feeds tables.
* **You own the filtering.** The legacy endpoint bakes in choices (which tokens to include, spam rules); with a
  feed those choices are yours, so you can match your product exactly.

## Adding the off-chain extras

When you need logos, spam/verification, or security scores, you have options:

* **Skip them** if your app doesn't use them.
* **Bring your own source**, a public token list for logos, or your own allow/deny lists.
* **Layer them in** from a dedicated metadata source alongside your Data Feeds tables.

## How this shows up in a migration guide

Each guide includes a **What to expect** section that applies this model to the specific endpoint, listing its
fields as *exact / calculated / add yourself*, plus a field-mapping table. Read it before you start so the
differences are choices you made, not surprises in production.