vfat APIvfat.io ↗
Access yield farming APRs, TVL, token prices, lending markets, and wallet portfolios across 30+ blockchains via the vfat.io API.
What is the vfat API?
The vfat.io API provides 11 endpoints covering DeFi yield farming farms, token data, lending markets, and wallet portfolio positions across 30+ blockchains. Use get_farms to retrieve paginated farm listings sorted by TVL with APR metrics, or get_portfolio to pull a wallet's native token balances, farm positions, and compound lending exposure in a single call. Response fields include chain IDs, contract addresses, underlying token compositions, and pending rewards.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/f29e46fc-b478-4aa1-9565-d097147f898d/get_chains' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace vfat-io-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: vfat.io DeFi Data API — bounded, re-runnable; every call capped."""
from parse_apis.vfat_io_defi_data_api import Vfat, ChainId, FarmNotFound
client = Vfat()
# Platform overview: TVL and user counts across all chains.
stats = client.overviews.get()
print(f"Platform TVL: ${stats.tvl:,.0f} | Users: {stats.unique_users} | Positions: {stats.positions_count}")
# List top farms on Base, capped to 3 items.
for farm in client.farms.list(chain_id=ChainId._8453, limit=3):
print(f"Farm {farm.address} — APR: {farm.apr:.2f}%, Liquidity: ${farm.active_liquidity:,.0f}")
# Drill into one farm for full detail via .first().
farm = client.farms.list(chain_id=ChainId._8453, limit=1).first()
if farm:
try:
detail = client.farms.get(address=farm.address, chain_id=ChainId._8453)
print(f"Detail: {detail.type} | stakingAPR={detail.staking_apr:.2f}% | lpAPR={detail.lp_apr:.2f}%")
except FarmNotFound as exc:
print(f"Farm gone: {exc}")
# Token list then navigate to detail via instance method.
token = client.tokens.list(limit=1).first()
if token:
td = token.details()
print(f"Token {td.symbol} on chain {td.chain_id}: {len(td.pools)} liquidity pools")
# Portfolio: fetch a wallet's holdings then walk sub-resources.
portfolio = client.portfolios.get(wallet="0x1234567890123456789012345678901234567890")
print(f"Wallet {portfolio.wallet}: {len(portfolio.balances)} balances, {len(portfolio.farm_balances)} farm positions")
# Chain-by-chain breakdown via sub-resource (constructible path).
for cb in client.portfolio(wallet="0x1234567890123456789012345678901234567890").chain_balances.list(limit=3):
print(f" {cb.chain_name}: ${cb.balance_usd:,.2f}")
# Data freshness check — how stale is each chain's data?
for lag in client.lags.list(limit=3):
print(f"Chain {lag.chain_id}: {lag.block_lag} blocks behind ({lag.time_lag_seconds:.0f}s)")
print("exercised: overviews.get / farms.list / farms.get / tokens.list / token.details / portfolios.get / portfolio.chain_balances.list / lags.list")Retrieve the list of supported blockchains on vfat.io, including RPC URLs, contract addresses, and native currency details. Returns all chains in a single response with no pagination.
No input parameters required.
{
"type": "array",
"fields": {
"sickle": "object with factory/registry contract addresses",
"chainId": "integer blockchain chain ID",
"chainName": "string blockchain name",
"nativeCurrency": "object with address, name, symbol, decimals",
"wrappedNativeToken": "object with name, symbol, address, decimals"
}
}About the vfat API
Farm and Token Data
The get_farms endpoint returns a paginated list of yield farms sorted by TVL descending. Each farm object includes id, type (e.g. AERODROME_V2, AERO_SLIPSTREAM_GAUGE), chainId, address, protocol, pool, apr, and TVL metrics. You can filter results by chain_id (e.g. 8453 for Base, 1 for Ethereum) or search directly by farm contract address. For deeper detail on a single farm, get_farm_detail returns pool composition with underlying tokens, activeLiquidity in USD, and the full protocol object. The get_tokens endpoint lists tracked tokens sorted by liquidity, exposing price, percentChange24h, and liquidity per token. get_token_detail extends this with the DEX liquidity pools associated with a given token contract.
Portfolio and Wallet Tracking
get_portfolio accepts any wallet address and returns balances (token holdings across chains), farm_balances (yield farming positions), compound_borrows, and compound_balances (lending supply positions) in one response. get_portfolio_chains narrows this to a per-chain USD breakdown, returning only chains where the wallet holds non-zero balances. get_yield_deposits targets vfat-tracked farm deposits specifically, returning farm type, LP token price, underlying token balances, pendingRewards, and farmAddress for each active position.
Lending Markets and Platform Stats
get_lending_markets lists compound-style DeFi lending markets across all supported chains. Each entry includes symbol, chainId, totalCash, totalBorrow, marketAddress, and an underlying object with token price. get_platform_stats exposes platform-wide aggregates: total tvl, uniqUsers, nbPositions, and per-chain breakdowns via chainStats. For monitoring data freshness, get_data_freshness reports blockLag, timeLagSeconds, and computedAt timestamps per chain, which is useful for applications that need to understand how current the aggregated on-chain data is.
The vfat API is a managed, monitored endpoint for vfat.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when vfat.io changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official vfat.io API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Aggregate top yield farms by TVL across Ethereum, Base, and other chains using
get_farmswithchain_idfiltering. - Display a DeFi wallet dashboard showing token balances, farm positions, and lending exposure via
get_portfolio. - Track pending farm rewards and underlying LP token compositions for a specific wallet using
get_yield_deposits. - Compare lending market supply and borrow totals across chains with
get_lending_markets. - Monitor 24-hour token price changes and liquidity rankings using
get_tokens. - Build a chain-by-chain portfolio allocation view using
get_portfolio_chainsUSD balances. - Alert on stale data pipelines by polling
get_data_freshnessfortimeLagSecondsper chain.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does vfat.io have an official developer API?+
What does `get_farm_detail` return that `get_farms` does not?+
get_farms returns summary-level fields suitable for listing — apr, tvl metrics, type, and protocol. get_farm_detail adds pool composition with underlying tokens, activeLiquidity in USD, and a more complete protocol object. It requires both address and chain_id as inputs and returns data for a single farm.How current is the data returned by these endpoints?+
get_data_freshness endpoint exposes blockLag (number of blocks behind the latest), timeLagSeconds, and a computedAt ISO timestamp for each supported chain. Applications that require strict latency guarantees should poll this endpoint to verify lag before acting on farm or portfolio data.Does the API expose historical farm APR or TVL time series data?+
get_farms, current token prices from get_tokens, and current lending totals from get_lending_markets. No historical time-series endpoints are included. You can fork this API on Parse and revise it to add a historical data endpoint if the underlying source exposes it.Can I filter `get_tokens` by chain or search by token symbol?+
get_tokens endpoint currently accepts only page and page_size as inputs and returns all tracked tokens sorted by liquidity. There is no chain_id or symbol filter on this endpoint. get_token_detail supports per-chain lookup by contract address and chain_id. You can fork this API on Parse and revise it to add symbol or chain filtering to the token list endpoint.