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

# How to Get Solana NFTs: Assets, Collections & Proofs

> Retrieve and query Solana NFTs, compressed NFTs, editions, and proofs using the Helius DAS API. Complete guide with code examples and best practices.

## Overview

This guide covers reading NFTs and digital collectibles with the Helius Digital Asset Standard (DAS) API: fetching a single asset, listing a wallet's NFTs, querying by collection or creator, working with compressed NFTs and Merkle proofs, listing editions, and reading transaction history.

For fungible tokens — balances, supply, holders, and prices — see the [Get SPL Tokens guide](https://www.helius.dev/docs/das/get-tokens.md). The same `getAsset` and `getAssetsByOwner` methods serve both NFTs and tokens; this page focuses on the NFT and collectible workflows.

## When to use this

Use the methods on this page when you are:

* Displaying a single NFT's metadata, image, and attributes
* Listing every NFT a wallet owns for a portfolio or gallery
* Powering a marketplace or explorer with collection and creator queries
* Verifying or transferring compressed NFTs (which require Merkle proofs)
* Showing an NFT's on-chain transaction history
* Listing the editions printed from a master NFT

## NFT methods

Start with `getAsset` for a single NFT or `getAssetsByOwner` for a wallet's collection. Each card links to its full API reference.

> [card] [getAsset](https://www.helius.dev/docs/api-reference/das/getasset.md)
>
> Full data for one NFT by its ID.

> [card] [getAssetsByOwner](https://www.helius.dev/docs/api-reference/das/getassetsbyowner.md)
>
> All NFTs held by a wallet.

> [card] [searchAssets](https://www.helius.dev/docs/das/search.md)
>
> Filter by collection, creator, attributes, and more — see the Search Assets guide.

> [card] [getAssetsByCreator](https://www.helius.dev/docs/api-reference/das/getassetsbycreator.md)
>
> All assets minted by a creator.

> [card] [getAssetsByGroup](https://www.helius.dev/docs/api-reference/das/getassetsbygroup.md)
>
> All assets in a collection.

> [card] [getSignaturesForAsset](https://www.helius.dev/docs/api-reference/das/getsignaturesforasset.md)
>
> Transaction history for an asset.

> [card] [getNftEditions](https://www.helius.dev/docs/api-reference/das/getnfteditions.md)
>
> Editions printed from a master NFT.

> [card] [getAssetProof](https://www.helius.dev/docs/api-reference/das/getassetproof.md)
>
> Merkle proof for a compressed NFT.

### Fetch a single NFT

Retrieve full metadata, ownership, and collection data for one NFT by its ID:

```typescript theme={"system"}
const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getAsset',
    params: { id: 'F9Lw3ki3hJ7PF9HQXsBzoY8GyE6sPoEZZdXJBsTTD2rk' },
  }),
});

const { result } = await response.json();
console.log(result.content.metadata.name, result.ownership.owner);
```

### More NFT queries

> [accordion] List a wallet's NFTs — getAssetsByOwner
>
> ```typescript theme={"system"}
> const getNFTsByOwner = async (ownerAddress) => {
>   const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
>     method: 'POST',
>     headers: { 'Content-Type': 'application/json' },
>     body: JSON.stringify({
>       jsonrpc: '2.0',
>       id: '1',
>       method: 'getAssetsByOwner',
>       params: { ownerAddress, page: 1, limit: 10 },
>     }),
>   });
>
>   const { result } = await response.json();
>   return result;
> };
>
> getNFTsByOwner('86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY');
> ```

> [accordion] By creator — getAssetsByCreator
>
> ```typescript theme={"system"}
> const getAssetsByCreator = async (creatorAddress) => {
>   const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
>     method: 'POST',
>     headers: { 'Content-Type': 'application/json' },
>     body: JSON.stringify({
>       jsonrpc: '2.0',
>       id: '1',
>       method: 'getAssetsByCreator',
>       params: { creatorAddress, page: 1, limit: 100 },
>     }),
>   });
>
>   const { result } = await response.json();
>   return result;
> };
>
> getAssetsByCreator('9uBX3ASjxWvNBAD1xjbVaKA74mWGZys3RGSF7DdeDD3F');
> ```

> [accordion] By collection — getAssetsByGroup
>
> ```typescript theme={"system"}
> const getAssetsByCollection = async (collectionAddress) => {
>   const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
>     method: 'POST',
>     headers: { 'Content-Type': 'application/json' },
>     body: JSON.stringify({
>       jsonrpc: '2.0',
>       id: '1',
>       method: 'getAssetsByGroup',
>       params: { groupKey: 'collection', groupValue: collectionAddress, page: 1, limit: 100 },
>     }),
>   });
>
>   const { result } = await response.json();
>   return result;
> };
>
> getAssetsByCollection('J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w');
> ```

> [accordion] Transaction history — getSignaturesForAsset
>
> ```typescript theme={"system"}
> const getNFTTransactionHistory = async (mintAddress) => {
>   const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
>     method: 'POST',
>     headers: { 'Content-Type': 'application/json' },
>     body: JSON.stringify({
>       jsonrpc: '2.0',
>       id: '1',
>       method: 'getSignaturesForAsset',
>       params: { id: mintAddress, page: 1, limit: 100 },
>     }),
>   });
>
>   const { result } = await response.json();
>   return result;
> };
>
> getNFTTransactionHistory('FNt6A9Mfnqbwc1tY7uwAguKQ1JcpBrxmhczDgbdJy5AC');
> ```

## Compressed NFTs

State-compressed NFTs (cNFTs) are **read** with the same methods as regular NFTs — `getAsset`, `getAssetsByOwner`, and `searchAssets` all return them. Two things are specific to compression:

* **Merkle proofs** — on-chain operations such as transfers and burns require a proof from `getAssetProof`.
* **History** — use `getSignaturesForAsset` (shown above) for a cNFT's transaction history.

> [accordion] Get a Merkle proof — getAssetProof
>
> ```typescript theme={"system"}
> const getProof = async (id) => {
>   const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
>     method: 'POST',
>     headers: { 'Content-Type': 'application/json' },
>     body: JSON.stringify({
>       jsonrpc: '2.0',
>       id: '1',
>       method: 'getAssetProof',
>       params: { id },
>     }),
>   });
>
>   const { result } = await response.json();
>   return result; // { root, proof, node_index, leaf, tree_id }
> };
>
> getProof('Bu1DEKeawy7txbnCEJE4BU3BKLXaNAKCYcHR4XhndGss');
> ```

## Best practices

* Use [pagination](https://www.helius.dev/docs/das/pagination.md) for methods that return large result sets.
* Handle errors with try/catch and retry transient failures with exponential backoff.
* Cache responses when appropriate to reduce API calls.
* Use `getAssetBatch` instead of many single `getAsset` calls when you have multiple IDs.

## Next steps

> [card] [Get SPL Tokens](https://www.helius.dev/docs/das/get-tokens.md)
>
> Fungible token balances, supply, holders, and prices.

> [card] [Search Assets](https://www.helius.dev/docs/das/search.md)
>
> Filter NFTs by collection, creator, and attributes.

> [card] [DAS API FAQ](https://www.helius.dev/docs/faqs/das-api.md)
>
> Common questions about assets, price data, and usage.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.