Fetching Assets

This guide shows how to fetch Core Assets and Collections from the Solana blockchain using the Metaplex Core SDK. Retrieve individual Assets, query by owner or collection, or use DAS for indexed queries.

Summary

Fetch Core Assets and Collections using SDK helper functions or the DAS API. Choose the right method based on your use case:

• Single Asset/Collection: Use fetchAsset() or fetchCollection() with the public key
• Multiple Assets: Use fetchAssetsByOwner(), fetchAssetsByCollection(), or fetchAssetsByUpdateAuthority()
• DAS API: Use indexed queries for faster performance (requires DAS-enabled RPC)

Out of Scope

Token Metadata fetching (use mpl-token-metadata), compressed NFT fetching (use Bubblegum DAS extensions), and off-chain metadata fetching (fetch the URI directly).

Quick Start

Jump to: Single Asset · By Owner · By Collection · DAS API

1. Install: npm install @metaplex-foundation/mpl-core @metaplex-foundation/umi
2. Configure Umi with your RPC endpoint
3. Call fetchAsset(umi, publicKey) with the Asset address
4. Access Asset properties: name, uri, owner, plugins

Prerequisites

• Umi configured with an RPC connection
• Asset/Collection address (public key) to fetch
• DAS-enabled RPC for indexed queries (optional but recommended)

Fetch a Single Asset or Collection

To fetch a single Asset the following function can be used:

1import { fetchAsset, fetchCollection, mplCore } from '@metaplex-foundation/mpl-core';
2import { publicKey } from '@metaplex-foundation/umi';
3import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
4
5// Initialize UMI
6const umi = createUmi('https://api.devnet.solana.com')
7  .use(mplCore())
8
9// Fetch a Core Asset
10const assetAddress = publicKey('AssetAddressHere...')
11const asset = await fetchAsset(umi, assetAddress)
12
13// Fetch a Core Collection
14const collectionAddress = publicKey('CollectionAddressHere...')
15const collection = await fetchCollection(umi, collectionAddress)
16
17console.log('Asset fetched:', asset)
18console.log('Name:', asset.name)
19console.log('Owner:', asset.owner)
20console.log('URI:', asset.uri)
21
22console.log('\nCollection fetched:', collection)
23console.log('Name:', collection.name)
24console.log('URI:', collection.uri)

import { fetchCollection } from '@metaplex-foundation/mpl-core'
const asset = await fetchCollection(umi, collection.publicKey, {
  skipDerivePlugins: false,
})
console.log(asset)

Fetch Multiple Assets

Multiple Assets can either be fetched using a getProgramAccounts (GPA) call, which can be quite expensive and slow RPC wise, or using the Digital Asset Standard API, which is faster but requires specific RPC providers.

Fetch Assets By Owner

import { publicKey } from '@metaplex-foundation/umi'
import { fetchAssetsByOwner } from '@metaplex-foundation/mpl-core'
const owner = publicKey('11111111111111111111111111111111')
const assetsByOwner = await fetchAssetsByOwner(umi, owner, {
  skipDerivePlugins: false,
})
console.log(assetsByOwner)

Fetch Assets by Collection

import { publicKey } from '@metaplex-foundation/umi'
import { fetchAssetsByCollection } from '@metaplex-foundation/mpl-core'
const collection = publicKey('11111111111111111111111111111111')
const assetsByCollection = await fetchAssetsByCollection(umi, collection, {
  skipDerivePlugins: false,
})
console.log(assetsByCollection)

Fetch Assets by Update Authority

To fetch a single Asset the following function can be used:

import { publicKey } from '@metaplex-foundation/umi'
import { fetchAssetsByUpdateAuthority } from '@metaplex-foundation/mpl-core'
const updateAuthority = publicKey('11111111111111111111111111111111')
const assetsByUpdateAuthority = await fetchAssetsByUpdateAuthority(
  umi,
  updateAuthority,
  { skipDerivePlugins: false }
)
console.log(assetsByUpdateAuthority)

DAS - Digital Asset Standard API

If you use a DAS enabled RPC you'll be able to take advantage of indexed Assets for lighting fast fetches and data retrieval. DAS will index everything from metadata, off chain metadata, collection data, plugins (including Attributes), and more. To learn more about the Metaplex DAS API you can click here. In addition to the general DAS SDK an extension for MPL Core has been created that directly returns you the correct types to further use with the MPL Core SDKs. It also automatically derives the plugins in assets inherited from the collection and provides functions for DAS-to-Core type conversions. Below is an example of returned data from fetching a MPL Core Asset with DAS.

FetchAsset Example

{
  "id": 0,
  "jsonrpc": "2.0",
  "result": {
    "authorities": [
      {
        "address": "Gi47RpRmg3wGsRRzFvcmyXHkELHznpx6DxEELGWBRWoC",
        "scopes": ["full"]
      }
    ],
    "burnt": false,
    "compression": {
      "asset_hash": "",
      "compressed": false,
      "creator_hash": "",
      "data_hash": "",
      "eligible": false,
      "leaf_id": 0,
      "seq": 0,
      "tree": ""
    },
    "content": {
      "$schema": "https://schema.metaplex.com/nft1.0.json",
      "files": [],
      "json_uri": "https://example.com/asset",
      "links": {},
      "metadata": {
        "name": "Test Asset",
        "symbol": ""
      }
    },
    "creators": [],
    "grouping": [
      {
        "group_key": "collection",
        "group_value": "8MPNmg4nyMGKdStSxbo2r2aoQGWz1pdjtYnQEt1kA2V7"
      }
    ],
    "id": "99A5ZcoaRSTGRigMpeu1u4wdgQsv6NgTDs5DR2Ug9TCQ",
    "interface": "MplCore",
    "mutable": true,
    "ownership": {
      "delegate": null,
      "delegated": false,
      "frozen": false,
      "owner": "Gi47RpRmg3wGsRRzFvcmyXHkELHznpx6DxEELGWBRWoC",
      "ownership_model": "single"
    },
    "plugins": {
      "FreezeDelegate": {
        "authority": {
          "Pubkey": {
            "address": "Gi47RpRmg3wGsRRzFvcmyXHkELHznpx6DxEELGWBRWoC"
          }
        },
        "data": {
          "frozen": false
        },
        "index": 0,
        "offset": 119
      }
    },
    "royalty": {
      "basis_points": 0,
      "locked": false,
      "percent": 0,
      "primary_sale_happened": false,
      "royalty_model": "creators",
      "target": null
    },
    "supply": null,
    "unknown_plugins": [
      {
        "authority": {
          "Pubkey": {
            "address": "Gi47RpRmg3wGsRRzFvcmyXHkELHznpx6DxEELGWBRWoC"
          }
        },
        "data": "CQA=",
        "index": 1,
        "offset": 121,
        "type": 9
      }
    ]
  }
}

Common Errors

Asset not found

The public key doesn't point to a valid Core Asset. Verify:

• The address is correct and on the expected network (devnet vs mainnet)
• The account exists and is a Core Asset (not Token Metadata)

RPC rate limit exceeded

GPA queries can be expensive. Solutions:

• Use a DAS-enabled RPC for indexed queries
• Add pagination to limit results
• Cache results where appropriate

Notes

• fetchAsset returns the full Asset including derived plugins from the Collection
• Set skipDerivePlugins: true to fetch only Asset-level plugins (faster)
• GPA queries (fetchAssetsByOwner, etc.) can be slow on mainnet - prefer DAS
• DAS returns off-chain metadata; SDK fetch functions return on-chain data only

Quick Reference

Fetch Functions

DAS vs GPA Comparison

FAQ

Should I use GPA or DAS for fetching multiple Assets?

Use DAS whenever possible. GPA queries scan all program accounts and can be slow and expensive on mainnet. DAS provides indexed queries that are faster and include off-chain metadata. See DAS RPC providers for compatible endpoints.

How do I fetch an Asset's off-chain metadata?

The uri field contains the metadata URL. Fetch it separately:

const asset = await fetchAsset(umi, assetAddress)
const metadata = await fetch(asset.uri).then(res => res.json())

Can I fetch Assets across multiple Collections?

Not in a single query. Fetch each Collection's Assets separately and combine the results, or use DAS with custom filters.

Why is skipDerivePlugins useful?

By default, fetchAsset derives Collection-level plugins onto the Asset. Setting skipDerivePlugins: true skips this step, returning only Asset-level plugins. Use this when you only need the Asset's own plugins or want faster fetches.

How do I paginate large result sets?

GPA functions don't support built-in pagination. For large collections, use DAS which supports page and limit parameters, or implement client-side pagination.

Glossary