DeFi Orbit vs. subgraphs
Subgraphs are a good way to read what a protocol has indexed. They give you entities and events, one protocol at a time. DeFi Orbit gives you finished positions: value, PnL, fees and history, in one schema across protocols. This page shows where the two differ and when each is the better choice.
What you get from each
What sits between a subgraph query and a number you can report
A subgraph answers the query you send it. Turning that answer into a position value, a PnL figure or a fee total is your work, and it is different for every protocol.
- 01Find the right subgraphOne per protocol and often one per chain, with different maintainers and different levels of upkeep.
- 02Learn each schemaField names, units and entity relationships differ between protocols and between versions.
- 03Paginate and joinResults are paginated with “first”, and The Graph advises against “skip” for large sets, so wallets with many positions need cursor-style queries stitched together.
- 04Fill in what is not indexedUncollected fees and pending rewards usually need on-chain calls next to the subgraph query.
- 05Add pricesA USD value for each token at the time of each deposit, withdrawal and collection.
- 06Write the calculationsPnL against holding, impermanent loss, APR and health factors, with rules you decide and document.
- 07Repeat for the next protocolLittle of the work carries over. Aerodrome is not Uniswap V3, and lending is a different model again.
What teams run into once subgraphs are in production
None of this is a flaw in subgraphs. It is what comes with using raw indexed data as a reporting source.
A subgraph is someone else’s schema
It was designed for the protocol’s own needs. Each deployment has its own schema, and fields can change when the subgraph is redeployed.
Sync status is your problem
When a subgraph falls behind or fails, your numbers go stale without an error. You need your own checks to notice.
The gaps need on-chain calls
Once you call contracts for fees and rewards, you are running RPC infrastructure next to the subgraph.
Every protocol is a new integration
Each one adds a schema, a set of edge cases and a set of formulas to maintain.
The calculations are still yours
When an investor or auditor asks how a figure was reached, your team owns the answer.
Query costs scale with usage
The first 100,000 queries a month are free on The Graph Network, then $2 per 100,000. That sounds cheap until every wallet, position and refresh is a query, and the RPC calls that fill the gaps sit on top.
When subgraphs are the better choice
Subgraphs do several things we do not. If one of these is your case, use them.
Protocol-wide analytics
Total volume, every pool, every swap. Subgraphs are built for this. Our API is built around wallets and positions.
A protocol or contract we do not cover
If a subgraph exists and we do not support the protocol, the subgraph is the faster route. You can also ask us about Custom Data.
Your own contracts
If you are indexing your own protocol, write a subgraph. That is what they are for.
You need decentralized infrastructure
Subgraphs on The Graph Network are served by independent indexers. DeFi Orbit is a hosted API.
Questions teams ask before deciding
Yes, and many setups should. Subgraphs are the right tool for protocol-wide questions, such as every pool, every swap or total volume, and DeFi Orbit is the right tool for what a specific wallet’s positions are worth and have earned. The two don’t overlap much, so there’s rarely a reason to pick one.
You replace three things with one call: the per-protocol GraphQL queries, the on-chain calls you make for uncollected fees and rewards, and the code that turns events into PnL and impermanent loss. One REST request per wallet or position returns the finished numbers, in the same shape for every protocol we cover.
Run the API on the wallets you already track and compare position by position. The methods for PnL, impermanent loss, fees and APR are documented, so where a figure differs you can see which rule explains it. Most differences come down to pricing at the time of an event or how fees are attributed after a rebalance.
Each endpoint has a fixed cost of 1 to 15 credits per call, and packs start at 500 credits for $10. Failed requests are free and purchased credits don’t expire while your account is active, so you can price your usage before you integrate. There’s no per-query metering to watch and no RPC bill behind it.
We add protocols and networks as scoped Custom Data projects, with a timeline and a price agreed before work starts. If a subgraph exists for a protocol we don’t cover, using it in the meantime is sensible, and we’ll say so.
No. Everything is read-only and works from public wallet addresses. There’s nothing to connect and nothing we could move.
Statements about subgraphs are linked to The Graph documentation and were last checked on October 13, 2026.
Compare the two on wallets you know
Run one API key next to your subgraph queries and see which numbers you would rather report.