Digital Asset Standard (DAS) API

Quick Reference: The DAS API provides a unified interface for all Solana assets. Use getAsset for single assets, getAssetsByOwner for wallet holdings, searchAssets for filtered queries, and specialized methods for compressed NFTs.

What is DAS?

The Digital Asset Standard (DAS) API is an open-source specification that provides a unified interface for interacting with all types of digital assets on Solana:

Regular NFTs (Non-Fungible Tokens)
Compressed NFTs (State Compression)
Fungible Tokens (including SPL Tokens and Token-2022)
Inscriptions and SPL-20 tokens (experimental)

Mainnet Endpoint

https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY

Devnet Endpoint

https://devnet.helius-rpc.com/?api-key=YOUR_API_KEY

Unified access to all Solana asset types
Comprehensive metadata retrieval
Off-chain data indexing (Arweave, IPFS)
Merkle proof support for compressed assets
Token price data for verified tokens
Advanced filtering and search capabilities

API Methods

Single Asset

Get detailed data for specific assets

Asset Collections

Get assets by owner, creator, or collection

Advanced Queries

Search and filter assets with complex criteria

Fetching Individual Assets

These methods let you retrieve detailed information about specific assets by their IDs.

// Get a single asset by its ID
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAsset = async (id) => {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "my-request-id",
      method: "getAsset",
      params: {
        id: id,
      },
    }),
  });
  
  const data = await response.json();
  return data.result;
};

// Example usage
getAsset("FNt6A9Mfnqbwc1tY7uwAguKQ1JcpBrxmhczDgbdJy5AC");

API Reference

View detailed documentation for getAsset

// Get a single asset by its ID
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAsset = async (id) => {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "my-request-id",
      method: "getAsset",
      params: {
        id: id,
      },
    }),
  });
  
  const data = await response.json();
  return data.result;
};

// Example usage
getAsset("FNt6A9Mfnqbwc1tY7uwAguKQ1JcpBrxmhczDgbdJy5AC");

API Reference

View detailed documentation for getAsset

// Get multiple assets (up to 1,000) in a single request
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetBatch = async (ids) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetBatch',
      params: {
        ids: ids
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetBatch([
  '81bxPqYCE8j34nQm7Rooqi8Vt3iMHLzgZJ71rUVbQQuz',
  'CWHuz6GPjWYdwt7rTfRHKaorMwZP58Spyd7aqGK7xFbn'
]);

API Reference

View detailed documentation for getAssetBatch

// Get Merkle proof for a compressed asset
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetProof = async (id) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetProof',
      params: {
        id: id
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetProof("Bu1DEKeawy7txbnCEJE4BU3BKLXaNAKCYcHR4XhndGss");

API Reference

View detailed documentation for getAssetProof

// Get Merkle proofs for multiple compressed assets
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetProofBatch = async (ids) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetProofBatch',
      params: {
        ids: ids
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetProofBatch([
  '81bxPqYCE8j34nQm7Rooqi8Vt3iMHLzgZJ71rUVbQQuz',
  'CWHuz6GPjWYdwt7rTfRHKaorMwZP58Spyd7aqGK7xFbn'
]);

API Reference

View detailed documentation for getAssetProofBatch

Fetching Asset Collections

These methods allow you to retrieve assets based on ownership, creation, authority, or collection membership.

All pagination in DAS API methods starts at 1 (not 0).

// Get all assets owned by a wallet address
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetsByOwner = async (ownerAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByOwner',
      params: {
        ownerAddress: ownerAddress,
        page: 1,
        limit: 1000,
        displayOptions: {
          showFungible: true, // Include SPL tokens
          showNativeBalance: true, // Include SOL balance
          showInscription: true, // Include inscription data
        },
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetsByOwner("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");

API Reference

View detailed documentation for getAssetsByOwner

// Get all assets owned by a wallet address
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetsByOwner = async (ownerAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByOwner',
      params: {
        ownerAddress: ownerAddress,
        page: 1,
        limit: 1000,
        displayOptions: {
          showFungible: true, // Include SPL tokens
          showNativeBalance: true, // Include SOL balance
          showInscription: true, // Include inscription data
        },
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetsByOwner("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");

API Reference

View detailed documentation for getAssetsByOwner

// Get all assets in a collection
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetsByGroup = async (collectionAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByGroup',
      params: {
        groupKey: 'collection',
        groupValue: collectionAddress,
        page: 1,
        limit: 1000,
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetsByGroup("J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w");

API Reference

View detailed documentation for getAssetsByGroup

// Get all assets by a specific creator
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetsByCreator = async (creatorAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByCreator',
      params: {
        creatorAddress: creatorAddress,
        onlyVerified: true,
        page: 1,
        limit: 1000,
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetsByCreator("D3XrkNZz6wx6cofot7Zohsf2KSsu2ArngNk8VqU9cTY3");

API Reference

View detailed documentation for getAssetsByCreator

// Get all assets with a specific authority
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getAssetsByAuthority = async (authorityAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByAuthority',
      params: {
        authorityAddress: authorityAddress,
        page: 1,
        limit: 1000,
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getAssetsByAuthority("2RtGg6fsFiiF1EQzHqbd66AhW7R5bWeQGpTbv2UMkCdW");

API Reference

View detailed documentation for getAssetsByAuthority

Advanced Query Methods

These methods allow for more specialized asset queries, including transaction history, NFT editions, and complex search filters.

// Search for assets with flexible criteria
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const searchAssets = async (searchParams) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'searchAssets',
      params: searchParams,
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example: Search for NFTs with specific traits
searchAssets({
  ownerAddress: "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  grouping: ["collection", "J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w"],
  traits: [
    { trait_type: "Background", values: ["Blue"] }
  ],
  limit: 100
});

API Reference

View detailed documentation for searchAssets

// Search for assets with flexible criteria
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const searchAssets = async (searchParams) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'searchAssets',
      params: searchParams,
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example: Search for NFTs with specific traits
searchAssets({
  ownerAddress: "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  grouping: ["collection", "J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w"],
  traits: [
    { trait_type: "Background", values: ["Blue"] }
  ],
  limit: 100
});

API Reference

View detailed documentation for searchAssets

// Get transaction history for a compressed asset
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getSignaturesForAsset = async (assetId) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getSignaturesForAsset',
      params: {
        id: assetId,
        page: 1,
        limit: 1000,
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getSignaturesForAsset("FNt6A9Mfnqbwc1tY7uwAguKQ1JcpBrxmhczDgbdJy5AC");

API Reference

View detailed documentation for getSignaturesForAsset

// Get all editions for a master NFT
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getNftEditions = async (masterMint) => {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "my-request-id",
      method: "getNftEditions",
      params: {
        mint: masterMint,
        page: 1,
        limit: 100
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example usage
getNftEditions("Ey2Qb8kLctbchQsMnhZs5DjY32To2QtPuXNwWvk4NosL");

API Reference

View detailed documentation for getNftEditions

// Get token accounts for a mint or owner
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getTokenAccounts = async (params) => {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "my-request-id",
      method: "getTokenAccounts",
      params: params,
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// Example: Get all accounts holding a specific token
getTokenAccounts({
  mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  page: 1,
  limit: 100
});

API Reference

View detailed documentation for getTokenAccounts

Working with Special Asset Types

Fungible Tokens

Access SPL tokens and get price data

Compressed NFTs

Work with state-compressed assets

Inscriptions

Access inscription and SPL-20 data

Off-chain Data

Retrieve metadata from Arweave/IPFS

Fungible Tokens

Helius has extended the DAS API to support all tokens, including plain SPL tokens (without metadata) and Token-2022 (plus their extensions). Fungible token support is available through the getAssetsByOwner and searchAssets methods.

// Get all tokens for a wallet including price data
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getTokensWithPrices = async (ownerAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByOwner',
      params: {
        ownerAddress: ownerAddress,
        displayOptions: {
          showFungible: true,
        },
      },
    }),
  });

  const { result } = await response.json();
  
  // Filter tokens that have price data
  const tokensWithPrices = result.items.filter(
    asset => asset.token_info?.price_info
  );
  
  return tokensWithPrices;
};

// Example usage
getTokensWithPrices("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");

Compressed NFTs

State-compressed NFTs (cNFTs) require special handling for operations like retrieving Merkle proofs and transaction history:

// Common operations with compressed NFTs
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

// 1. Get a compressed NFT
const getCompressedNft = async (id) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAsset',
      params: { id },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// 2. Get Merkle proof for verification
const getProof = async (id) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetProof',
      params: { id },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

// 3. Get transaction history
const getTransactionHistory = async (id) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getSignaturesForAsset',
      params: { 
        id,
        page: 1,
        limit: 100
      },
    }),
  });
  
  const { result } = await response.json();
  return result;
};

Inscriptions & SPL-20

You can optionally display inscription and SPL-20 token data with the showInscription flag. This is an experimental feature.

// Get inscriptions for a wallet
const url = `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY`;

const getInscriptionsForWallet = async (ownerAddress) => {
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-request-id',
      method: 'getAssetsByOwner',
      params: {
        ownerAddress: ownerAddress,
        displayOptions: {
          showInscription: true,
        },
      },
    }),
  });

  const { result } = await response.json();
  
  // Filter results to only include assets with inscription data
  const inscriptions = result.items.filter(
    asset => asset.inscription
  );
  
  return inscriptions;
};

// Example usage
getInscriptionsForWallet("6GmTFg5SCs4zGfDEidUAJjS5pSrXEPwW8Rpfs3RHrbc5");

Off-chain Data

Off-chain Data Retrieval

Best Practices

Pagination

Start at page 1 (not 0)
Use reasonable limit values (100-1000)
Implement robust pagination for large datasets

Error Handling

Always check for errors in responses
Implement retries with exponential backoff
Handle edge cases like invalid parameters

Performance

Use batch methods when possible
Cache responses when appropriate
Avoid chaining multiple requests when one will do

Security

Never expose your API key in client-side code
Use server-side functions to proxy API requests
Set up appropriate CORS policies

Resources

API References

Full API documentation for all DAS methods

GitHub Repository

DAS API open-source specification

Examples & SDKs

Get started with client libraries and code samples

Enhanced Transactions API

Fungible Token Extension

On this page

What is DAS?
API Methods
Fetching Individual Assets
Fetching Asset Collections
Advanced Query Methods
Working with Special Asset Types
Fungible Tokens
Compressed NFTs
Inscriptions & SPL-20
Off-chain Data
Best Practices
Resources

Get Started

Solana RPC Nodes

Dedicated Nodes

Data Streaming & Event Listening

Sending Transactions

Getting Data Using Helius APIs

Compression

Staking

Billing

Resources

​What is DAS?

Mainnet Endpoint

Devnet Endpoint

​API Methods

Single Asset

Asset Collections

Advanced Queries

​Fetching Individual Assets

API Reference

API Reference

API Reference

API Reference

API Reference

​Fetching Asset Collections

API Reference

API Reference

API Reference

API Reference

API Reference

​Advanced Query Methods

API Reference

API Reference

API Reference

API Reference

API Reference

​Working with Special Asset Types

Fungible Tokens

Compressed NFTs

Inscriptions

Off-chain Data

​Fungible Tokens

​Compressed NFTs

​Inscriptions & SPL-20

​Off-chain Data

​Best Practices

Pagination

Error Handling

Performance

Security

​Resources

API References

GitHub Repository

Examples & SDKs

What is DAS?

API Methods

Fetching Individual Assets

Fetching Asset Collections

Advanced Query Methods

Working with Special Asset Types

Fungible Tokens

Compressed NFTs

Inscriptions & SPL-20

Off-chain Data

Best Practices

Resources