NFT Indexing on Solana: The DAS API, Compressed NFTs and Custom Indexers

NFT Indexing on Solana: The DAS API, Compressed NFTs and Custom Indexers

To index NFTs on Solana you need to quickly determine "which assets does this wallet own" and "what is this asset's metadata", and the standard way of carrying out this task in 2026 is through the Digital Asset Standard (DAS) API, a provider-side index which includes both regular NFTs and compressed NFTs as well as fungible tokens by means of a single query interface.

You should only create your own index in the cases where the DAS API does not answer your questions or when you want to assume responsibility for the data; this guide looks at how NFTs are depicted on the blockchain, explains why compressed NFTs made indexing necessary, describes what the DAS API provides, and outlines how to make a custom NFT indexer when this is required.

Key Takeaways

• An NFT on Solana is made up of a mint having a supply of one and a metadata account; a compressed NFT is a leaf in a Merkle tree with the data being recorded in the transaction logs. It is impossible to retrieve the second of these using getAccountInfo.
• The DAS API deals with issues relating to ownership, metadata, collections and search queries for both types via a provider index, including the use of pagination and it does not require any program scans on your side.
• To find the NFTs of a wallet by using getProgramAccounts on the token program is slow, expensive and incomplete (as it does not include compressed assets); instead use getTokenAccountsByOwner for regular tokens and DAS for all cases.
• If you need your own schema, custom collection logic, or analytics that DAS doesn't offer, then create a custom index by using a gRPC stream along with an archive backfill.

How NFTs are represented on Solana

Regular NFTs (in accordance with the Metaplex Token Metadata standard): these are tokens which have a supply of one and no decimals, along with a token account that holds them and a metadata account (which is a PDA of the mint) that points to off-chain JSON containing the name, image, and attributes; the ownership is held by the person who owns the token account; in order to read such a token a number of getAccountInfo calls must be made.

In the case of Compressed NFTs (Metaplex Bubblegum), the asset data is hashed and then added as a leaf to a Merkle tree that is stored in a concurrent Merkle tree account. The full data is not held in any account; rather, it is transmitted as part of the transaction that creates or alters the leaf. As a result, minting a large number of assets is inexpensive, but this also means that it is impossible to retrieve the data using account queries since in order to find out what a compressed NFT is you have to use an index which replays the transactions of the tree.

The Token-2022 assets have extensions (for example metadata pointers, transfer hooks and transfer fees) which change the location of the metadata and the manner in which transfers operate.

What caused NFT indexing to turn into a service that is offered by providers rather than being included in a client library was the development of compressed NFTs.

The DAS API

The Digital Asset Standard API is an extension of JSON-RPC that is offered by most Solana providers and is supported by an index which the providers maintain on their own. The primary methods:

The index handles both regular and compressed NFTs in the same manner and, on most providers, also covers fungible tokens, meaning that a single query gives a full view of a wallet's contents with the metadata resolved. It is due to the getAssetProof method that compressed NFTs can be transferred; compressed assets remain transferable only if the index is able to produce the proof.

You should use DAS whenever you have the same type of questions that it addresses, since a single call is enough to replace program scans, metadata resolution, and proof generation. Someone else is responsible for keeping it up to date.

Doing it the slow way, and why not to

The conventional method consists of using getProgramAccounts or getTokenAccountsByOwner to find token accounts that have a balance of one, then calling getAccountInfo on each mint's metadata PDA and subsequently obtaining the relevant off-chain JSON files. This method requires a large number of calls per wallet, is slow, becomes expensive under a credit-based pricing model, and does not at all deal with compressed NFTs. With regard to NFTs, DAS is the available alternative.

If you have no need for metadata, getTokenAccountsByOwner is still the right option if you want to find a wallet's fungible token balances.

When to build your own NFT index

• Your own schema: you need to combine the asset data with your application's data or adapt it for the queries that DAS does not support.
• Custom collection or trait logic: rarity scoring, derived attributes, and cross-collection relationships.
• Analytics: analysis of sales history, the changes over time in holder distributions, and the identification of wash trades.
• Independence: you want the data to be kept on your own servers and not on the provider's API.

The system includes a general indexer along with decoders that are specific to NFTs; in order to subscribe, one must use Yellowstone gRPC together with the Token Metadata, Bubblegum and Token-2022 programs, decode the metadata accounts and, where applicable, the Bubblegum instruction logs which contain the leaf data, asynchronously resolve the off-chain JSON by means of caching, and then fill in the missing history using the archive RPC. The most difficult part of decoding Bubblegum is that it involves reconstructing the assets from the instruction data and log events and requires the state of the tree to be tracked in order to produce proofs.

A lot of teams end up running both, with DAS handling ownership and proofs while a custom index takes care of the analytics.

Practical notes

• Off-chain metadata: the JSON at the URI is not kept on the blockchain and may thus be altered or disappear, so you should cache it and use the on-chain metadata account as the authoritative source for the name and symbol.
• Pagination: On DAS, when it comes to large wallets and collections the pagination is based on a cursor; you must navigate through it entirely rather than suppose that it consists of a single page.
• Freshness: the provider's indexes are slightly lagging behind the chain. If you want to detect transfers in real time, you should subscribe to the relevant programs or to the wallet's token accounts via gRPC and then use DAS to get the resolved view.
• Compressed transfers: since you need a current proof, you should use the getAssetProof function to obtain the proof right before constructing the transaction, as any changes to the tree cause previous proofs to become invalid.

Conclusion

Solana NFTs come in three types: regular, compressed, and Token-2022; since with compressed assets the data is stored in transaction logs rather than in the accounts, a provider-side index is necessary. The DAS API functions as this index and, through a single interface, provides information regarding ownership, metadata, collections, search and Merkle proofs. You should use it whenever you need to find out any of these things, use the getTokenAccountsByOwner method if all you want to know is the plain token balances, and only build your own index for the schemas and analytics that DAS does not deal with, employing the gRPC-plus-archive architecture which is used by all indexers.

OrbitFlare's RPC plans feature the standard methods, its gRPC service handles the real-time path, and the historical data is provided for use with a custom index.

Resources

1. Metaplex DAS API methods
2. Metaplex Bubblegum (compressed NFTs)
3. Solana Token-2022 extensions
4. OrbitFlare Solana gRPC streaming
5. OrbitFlare historical data (archive nodes)