DAS API guides, umi renderer (#372)

* DAS API guides and renderer improvements: pagination, parameter structure, navigation, and link fixes

* use totem for examples

* umi default

* fix searchAsset grouping

* fix script

* fix find-compressed-nft

* add JS examples

* more examples

* make functions async

* code alignments

* endpoints

* Update src/pages/das-api/guides/get-collection-nfts.md

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* Update src/pages/das-api/guides/find-token-holders.md

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* CR suggestions

* Apply suggestions from code review

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* Apply suggestions from code review

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* code review

* fix pagination page

* Fix markdown lint violations in DAS API guides

- Add blank lines around code blocks in totem accordions (MD031)
- Remove colons from headings and add proper spacing (MD026, MD022, MD032)
- Fix pagination page rendering issue with missing code fence
- Improve markdown consistency across all guide files

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* code rabbit review

* more coderabbit

* Update src/components/apiComponents/languageComponents/umiRequestRenderer.jsx

Co-authored-by: Tony Boyle <81017245+tonyboylehub@users.noreply.github.com>

* fix creatorVerified

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Tony Boyle <81017245+tonyboylehub@users.noreply.github.com>

src/components/apiComponents/languageComponents/umiRequestRenderer.jsx

@@ -0,0 +1,236 @@
+import { Fence } from '@/components/Fence';
+
+import PropTypes from 'prop-types';
+
+const UmiRequestRenderer = ({
+  url,
+  headers,
+  bodyMethod,
+  rpcVersion,
+  bodyParams,
+  id,
+}) => {
+
+  const httpBody = bodyParams;
+
+  // Convert display options to UMI format with proper formatting
+  const convertDisplayOptions = (options) => {
+    if (!options) return '';
+
+    const displayOptions = [];
+    if (options.showCollectionMetadata !== undefined) {
+      displayOptions.push(`    showCollectionMetadata: ${options.showCollectionMetadata}`);
+    }
+    if (options.showFungible !== undefined) {
+      displayOptions.push(`    showFungible: ${options.showFungible}`);
+    }
+    if (options.showInscription !== undefined) {
+      displayOptions.push(`    showInscription: ${options.showInscription}`);
+    }
+    if (options.showUnverifiedCollections !== undefined) {
+      displayOptions.push(`    showUnverifiedCollections: ${options.showUnverifiedCollections}`);
+    }
+    if (options.showZeroBalance !== undefined) {
+      displayOptions.push(`    showZeroBalance: ${options.showZeroBalance}`);
+    }
+
+    return displayOptions.length > 0 ? `{\n${displayOptions.join(',\n')}\n  }` : '';
+  };
+
+  // Convert parameters to UMI format using object-based input types with proper formatting
+  const convertParamsToUmi = (params, method) => {
+    if (!params) return '';
+
+    if (!method) {
+      console.warn('UmiRequestRenderer: No method specified');
+      return '';
+    }
+    switch (method) {
+      case 'getAsset': {
+        const assetParams = [];
+        if (params.id) {
+          assetParams.push(`  id: publicKey('${params.id}')`);
+        } else {
+          assetParams.push(`  id: publicKey('')`);
+        }
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) assetParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${assetParams.join(',\n')}\n}`;
+      }
+      case 'getAssets': {
+        const assetsParams = [];
+        if (params.ids && Array.isArray(params.ids)) {
+          const idsList = params.ids.map(id => `    publicKey('${id}')`).join(',\n');
+          assetsParams.push(`  ids: [\n${idsList}\n  ]`);
+        } else {
+          assetsParams.push(`  ids: []`);
+        }
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) assetsParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${assetsParams.join(',\n')}\n}`;
+      }
+      case 'getAssetsByOwner': {
+        const ownerParams = [];
+        if (params.ownerAddress) ownerParams.push(`  owner: publicKey('${params.ownerAddress}')`);
+        if (params.limit) ownerParams.push(`  limit: ${params.limit}`);
+        if (params.page) ownerParams.push(`  page: ${params.page}`);
+        if (params.before) ownerParams.push(`  before: publicKey('${params.before}')`);
+        if (params.after) ownerParams.push(`  after: publicKey('${params.after}')`);
+        if (params.sortBy) {
+          const sortBy = typeof params.sortBy === 'object' ? params.sortBy : { sortBy: params.sortBy, sortDirection: 'desc' };
+          ownerParams.push(`  sortBy: {\n    sortBy: '${sortBy.sortBy || 'created'}',\n    sortDirection: '${sortBy.sortDirection || 'desc'}'\n  }`);
+        }
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) ownerParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${ownerParams.join(',\n')}\n}`;
+      }
+      case 'getAssetsByCreator': {
+        const creatorParams = [];
+        if (params.creatorAddress) creatorParams.push(`  creator: publicKey('${params.creatorAddress}')`);
+        if (params.onlyVerified !== undefined) creatorParams.push(`  onlyVerified: ${params.onlyVerified}`);
+        if (params.limit) creatorParams.push(`  limit: ${params.limit}`);
+        if (params.page) creatorParams.push(`  page: ${params.page}`);
+        if (params.before) creatorParams.push(`  before: publicKey('${params.before}')`);
+        if (params.after) creatorParams.push(`  after: publicKey('${params.after}')`);
+        if (params.sortBy) {
+          const sortBy = typeof params.sortBy === 'object' ? params.sortBy : { sortBy: params.sortBy, sortDirection: 'desc' };
+          creatorParams.push(`  sortBy: {\n    sortBy: '${sortBy.sortBy || 'created'}',\n    sortDirection: '${sortBy.sortDirection || 'desc'}'\n  }`);
+        }
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) creatorParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${creatorParams.join(',\n')}\n}`;
+      }
+      case 'getAssetsByAuthority': {
+        const authorityParams = [];
+        if (params.authorityAddress) authorityParams.push(`  authority: publicKey('${params.authorityAddress}')`);
+        if (params.limit) authorityParams.push(`  limit: ${params.limit}`);
+        if (params.page) authorityParams.push(`  page: ${params.page}`);
+        if (params.before) authorityParams.push(`  before: publicKey('${params.before}')`);
+        if (params.after) authorityParams.push(`  after: publicKey('${params.after}')`);
+        if (params.sortBy) {
+          const sortBy = typeof params.sortBy === 'object' ? params.sortBy : { sortBy: params.sortBy, sortDirection: 'desc' };
+          authorityParams.push(`  sortBy: {\n    sortBy: '${sortBy.sortBy || 'created'}',\n    sortDirection: '${sortBy.sortDirection || 'desc'}'\n  }`);
+        }
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) authorityParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${authorityParams.join(',\n')}\n}`;
+      }
+      case 'getAssetsByGroup': {
+                const groupParams = [];
+        if (params.groupKey) {
+          groupParams.push(`  groupKey: '${params.groupKey}'`);
+        } else {
+          groupParams.push(`  groupKey: ''`);
+        }
+        if (params.groupValue) {
+          groupParams.push(`  groupValue: '${params.groupValue}'`);
+        } else {
+          groupParams.push(`  groupValue: ''`);
+        }
+        if (params.limit) groupParams.push(`  limit: ${params.limit}`);
+        if (params.page) groupParams.push(`  page: ${params.page}`);
+        if (params.before) groupParams.push(`  before: publicKey('${params.before}')`);
+        if (params.after) groupParams.push(`  after: publicKey('${params.after}')`);
+        if (params.sortBy) {
+          const sortBy = typeof params.sortBy === 'object' ? params.sortBy : { sortBy: params.sortBy, sortDirection: 'desc' };
+          groupParams.push(`  sortBy: {\n    sortBy: '${sortBy.sortBy || 'created'}',\n    sortDirection: '${sortBy.sortDirection || 'desc'}'\n  }`);
+        }
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) groupParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${groupParams.join(',\n')}\n}`;
+      }
+      case 'searchAssets': {
+        const searchParams = [];
+        if (params.ownerAddress) searchParams.push(`  owner: publicKey('${params.ownerAddress}')`);
+        if (params.creatorAddress) searchParams.push(`  creator: publicKey('${params.creatorAddress}')`);
+        if (params.authorityAddress) searchParams.push(`  authority: publicKey('${params.authorityAddress}')`);
+        if (params.grouping && Array.isArray(params.grouping) && params.grouping.length >= 2) {
+          searchParams.push(`  grouping: [\n    '${params.grouping[0]}',\n    '${params.grouping[1]}'\n   ]`);
+        }
+        if (params.jsonUri) searchParams.push(`  jsonUri: '${params.jsonUri}'`);
+        if (params.limit) searchParams.push(`  limit: ${params.limit}`);
+        if (params.page) searchParams.push(`  page: ${params.page}`);
+        if (params.before) searchParams.push(`  before: publicKey('${params.before}')`);
+        if (params.after) searchParams.push(`  after: publicKey('${params.after}')`);
+        if (params.interface) searchParams.push(`  interface: '${params.interface}'`);
+        if (params.ownerType) searchParams.push(`  ownerType: '${params.ownerType}'`);
+        if (params.creatorVerified !== undefined) searchParams.push(`  creatorVerified: ${params.creatorVerified}`);
+        if (params.delegateAddress) searchParams.push(`  delegate: publicKey('${params.delegateAddress}')`);
+        if (params.frozen !== undefined) searchParams.push(`  frozen: ${params.frozen}`);
+        if (params.supply) searchParams.push(`  supply: ${params.supply}`);
+        if (params.supplyMint) searchParams.push(`  supplyMint: publicKey('${params.supplyMint}')`);
+        if (params.compressed !== undefined) searchParams.push(`  compressed: ${params.compressed}`);
+        if (params.compressible !== undefined) searchParams.push(`  compressible: ${params.compressible}`);
+        if (params.royaltyTargetType) searchParams.push(`  royaltyTargetType: '${params.royaltyTargetType}'`);
+        if (params.royaltyTarget) searchParams.push(`  royaltyTarget: publicKey('${params.royaltyTarget}')`);
+        if (params.royaltyAmount) searchParams.push(`  royaltyAmount: ${params.royaltyAmount}`);
+        if (params.burnt !== undefined) searchParams.push(`  burnt: ${params.burnt}`);
+        if (params.sortBy) {
+          const sortBy = typeof params.sortBy === 'object' ? params.sortBy : { sortBy: params.sortBy, sortDirection: 'desc' };
+          searchParams.push(`  sortBy: {\n    sortBy: '${sortBy.sortBy || 'created'}',\n    sortDirection: '${sortBy.sortDirection || 'desc'}'\n  }`);
+        }
+        if (params.negate !== undefined) searchParams.push(`  negate: ${params.negate}`);
+        if (params.conditionType) searchParams.push(`  conditionType: '${params.conditionType}'`);
+        if (params.options) {
+          const displayOptions = convertDisplayOptions(params.options);
+          if (displayOptions) searchParams.push(`  displayOptions: ${displayOptions}`);
+        }
+        return `{\n${searchParams.join(',\n')}\n}`;
+      }
+      case 'getAssetProof': {
+        if (!params.id) return '';
+        return `publicKey('${params.id}')`;
+      }
+      case 'getAssetProofs': {
+        if (!params.ids || !Array.isArray(params.ids)) return '[]';
+        const proofIds = params.ids.map(id => `  publicKey('${id}')`).join(',\n');
+        return `[\n${proofIds}\n]`;
+      }
+      case 'getAssetSignatures': {
+        const signatureParams = [];
+        if (params.id) signatureParams.push(`  assetId: publicKey('${params.id}')`);
+        if (params.limit) signatureParams.push(`  limit: ${params.limit}`);
+        if (params.page) signatureParams.push(`  page: ${params.page}`);
+        if (params.before) signatureParams.push(`  before: '${params.before}'`);
+        if (params.after) signatureParams.push(`  after: '${params.after}'`);
+        if (params.sortDirection) signatureParams.push(`  sortDirection: '${params.sortDirection}'`);
+        return `{\n${signatureParams.join(',\n')}\n}`;
+      }
+      default: {
+        console.warn(`UmiRequestRenderer: Unsupported method: ${method}`);
+        return JSON.stringify(params);
+      }
+    }
+  };
+
+  const umiParams = convertParamsToUmi(httpBody, bodyMethod);
+
+  const code = `import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('${url}').use(dasApi())
+
+const result = await umi.rpc.${bodyMethod}(${umiParams})
+console.log(result)`;
+
+  return (
+    <Fence className="w-full" language="javascript">
+      {code}
+    </Fence>
+  );
+};
+
+export default UmiRequestRenderer; 

src/components/apiComponents/languageRenderer.jsx

@@ -1,19 +1,20 @@
-import { useState } from 'react'
-import EndPointSelector from './endPointSelector'
-import CSharpRequestRenderer from './languageComponents/cSharpRenderer'
-import CurlRequestRenderer from './languageComponents/curlRequestRenderer'
-import GoRequestRenderer from './languageComponents/goRequestRenderer'
-import JavaRenderer from './languageComponents/javaRenderer'
-import JavascriptRequestRenderer from './languageComponents/javascriptRequestRenderer'
-import PhpRenderer from './languageComponents/phpRenderer'
-import PythonRequestRenderer from './languageComponents/pythonRequestRenderer'
-import RubyRenderer from './languageComponents/rubyRenderer'
-import RustRequestRenderer from './languageComponents/rustRenderer'
-import SwiftRequestRenderer from './languageComponents/swiftRenderer'
-import LanguageSelector from './languageSelector'
+import { useState } from 'react';
+import EndPointSelector from './endPointSelector';
+import CSharpRequestRenderer from './languageComponents/cSharpRenderer';
+import CurlRequestRenderer from './languageComponents/curlRequestRenderer';
+import GoRequestRenderer from './languageComponents/goRequestRenderer';
+import JavaRenderer from './languageComponents/javaRenderer';
+import JavascriptRequestRenderer from './languageComponents/javascriptRequestRenderer';
+import PhpRenderer from './languageComponents/phpRenderer';
+import PythonRequestRenderer from './languageComponents/pythonRequestRenderer';
+import RubyRenderer from './languageComponents/rubyRenderer';
+import RustRequestRenderer from './languageComponents/rustRenderer';
+import SwiftRequestRenderer from './languageComponents/swiftRenderer';
+import UmiRequestRenderer from './languageComponents/umiRequestRenderer';
+import LanguageSelector from './languageSelector';
 
 const LanguageRenderer = ({ api, body, setActiveEndpoint, activeEndpoint }) => {
-  const [activeLanguage, setActiveLanguage] = useState('javascript')
+  const [activeLanguage, setActiveLanguage] = useState('umi')
 
   function strToTitleCase(str) {
     return str.charAt(0).toUpperCase() + str.slice(1)
@@ -196,6 +197,21 @@ const LanguageRenderer = ({ api, body, setActiveEndpoint, activeEndpoint }) => {
             />
           </div>
         )
+      case 'umi':
+        return (
+          <div className="flex flex-col">
+            <div className="-mb-3 text-sm font-medium text-gray-800 dark:text-neutral-400">
+              {strToTitleCase(activeLanguage)} Request Example
+            </div>
+            <UmiRequestRenderer
+              method={api.method}
+              url={activeEndpoint}
+              headers={headers}
+              bodyMethod={body.method}
+              bodyParams={body.params}
+            />
+          </div>
+        )
     }
   }
 

src/components/apiComponents/languageSelector.jsx

@@ -1,6 +1,7 @@
-import { Icon } from '@/components/icons'
+import { Icon } from '@/components/icons';
 
 const languages = [
+  { name: 'umi', icon: 'SolidCodeBracketSquare' },
   { name: 'curl', icon: 'CurlIcon' },
   { name: 'javascript', icon: 'JavaScriptIcon' },
   { name: 'python', icon: 'PythonIcon' },

src/components/products/das-api/index.js

@@ -1,8 +1,8 @@
 import {
   documentationSection
-} from '@/shared/sections'
-import { TableCellsIcon } from '@heroicons/react/24/solid'
-import { Hero } from './Hero'
+} from '@/shared/sections';
+import { TableCellsIcon } from '@heroicons/react/24/solid';
+import { Hero } from './Hero';
 
 export const das = {
   name: 'DAS API',
@@ -25,10 +25,11 @@ export const das = {
             { title: 'Overview', href: '/das-api' },
             { title: 'Getting Started', href: '/das-api/getting-started' },
             { title: 'DAS API RPC Providers', href: '/rpc-providers' },
+            { title: 'Display Options', href: '/das-api/display-options' },
           ],
         },
         {
-          title: 'Methods',
+          title: 'Methods & Playground',
           links: [
             { title: 'Method Overview', href: '/das-api/methods' },
             { title: 'Get Asset', href: '/das-api/methods/get-asset' },
@@ -43,6 +44,22 @@ export const das = {
             { title: 'Search Assets', href: '/das-api/methods/search-assets' },
           ],
         },
+        {
+          title: 'Guides',
+          links: [
+            { title: 'Guides Overview', href: '/das-api/guides' },
+            { title: 'Pagination', href: '/das-api/guides/pagination' },
+            { title: 'Get Collection NFTs', href: '/das-api/guides/get-collection-nfts' },
+            { title: 'Get NFTs by Owner', href: '/das-api/guides/get-nfts-by-owner' },
+            { title: 'Get Wallet Tokens', href: '/das-api/guides/get-wallet-tokens' },
+            { title: 'Get Fungible Assets', href: '/das-api/guides/get-fungible-assets' },
+            { title: 'Search by Criteria', href: '/das-api/guides/search-by-criteria' },
+            { title: 'Owner and Collection', href: '/das-api/guides/owner-and-collection' },
+            { title: 'Find Compressed NFTs', href: '/das-api/guides/find-compressed-nfts' },
+            { title: 'Collection Statistics', href: '/das-api/guides/collection-statistics' },
+            { title: 'Find Token Holders', href: '/das-api/guides/find-token-holders' },
+          ],
+        },
         {
           title: 'Core Extension SDK',
           links: [

src/lib/api/aura/das/searchAssest.js

@@ -48,7 +48,7 @@ const searchAssets = {
       description: 'The creator address of the asset',
     },
     {
-      name: 'createVerified',
+      name: 'creatorVerified',
       type: 'boolean',
       description: 'Indicates whether the creator must be verified or not.',
     },

src/pages/das-api/display-options.md

@@ -0,0 +1,95 @@
+---
+title: Display Options
+metaTitle: Display Options | DAS API
+description: Learn about the display options available in DAS API methods
+---
+
+The DAS API provides display options that allow you to control what additional information is included in the response. These options are available as an `options` object parameter in several API methods.
+
+## Available Display Options
+
+| Option | Type | Description | Default |
+|--------|------|-------------|---------|
+| `showCollectionMetadata` | boolean | When `true`, includes collection metadata in the response. This provides information about the collection the asset belongs to. | `false` |
+| `showFungible` | boolean | When `true`, includes fungible token information in the response. This is useful for assets that represent fungible tokens or if you want to `getAssetsByOwner` and actually see all assets. | `false` |
+| `showInscription` | boolean | When `true`, includes inscription data in the response. This provides information about any inscriptions associated with the included asset. | `false` |
+| `showUnverifiedCollections` | boolean | When `true`, includes unverified collections in the response. By default, only verified collections are shown. | `false` |
+| `showZeroBalance` | boolean | When `true`, includes token accounts with zero balance in the response. By default, only accounts with non-zero balances are shown. | `false` |
+
+## Usage Examples
+
+### Basic Usage
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+// Get an asset with collection metadata
+const asset = await umi.rpc.getAsset({
+  id: publicKey('your-asset-id'),
+  displayOptions: {
+    showCollectionMetadata: true
+  }
+})
+```
+
+### Multiple Options
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+// Get assets with multiple display options enabled
+const assets = await umi.rpc.getAssetsByOwner({
+  owner: publicKey('owner-address'),
+  displayOptions: {
+    showCollectionMetadata: true,
+    showFungible: true,
+    showInscription: true
+  }
+})
+```
+
+### All Options Enabled
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+// Enable all display options
+const assets = await umi.rpc.searchAssets({
+  owner: publicKey('owner-address'),
+  displayOptions: {
+    showCollectionMetadata: true,
+    showFungible: true,
+    showInscription: true,
+    showUnverifiedCollections: true,
+    showZeroBalance: true
+  }
+})
+```
+
+## Methods That Support Display Options
+
+The following DAS API methods support the `options` parameter with display options:
+
+- [Get Asset](/das-api/methods/get-asset)
+- [Get Assets](/das-api/methods/get-assets)
+- [Get Assets By Owner](/das-api/methods/get-assets-by-owner)
+- [Get Assets By Creator](/das-api/methods/get-assets-by-creator)
+- [Get Assets By Authority](/das-api/methods/get-assets-by-authority)
+- [Get Assets By Group](/das-api/methods/get-assets-by-group)
+- [Search Assets](/das-api/methods/search-assets)
+
+## Performance Considerations
+
+Enabling display options may increase response size and processing time. Only enable the options you need for your specific use case to optimize performance. 

src/pages/das-api/guides/collection-statistics.md

@@ -0,0 +1,153 @@
+---
+title: Analyze Collection Statistics
+metaTitle: Analyze Collection Statistics | DAS API Guides
+description: Learn how to get insights about collection distribution and ownership using the DAS API
+---
+
+# Analyze Collection Statistics
+
+This guide shows you how to analyze collection statistics, distribution, and ownership patterns using the DAS API. This is useful for building analytics dashboards, marketplace insights, or collection management tools.
+
+## Basic Collection Statistics
+
+Get fundamental statistics about a collection including total assets, ownership distribution. Be creative with the results and use the data to build your own insights.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  async function getCollectionStatistics(collectionAddress) {
+    // Get all assets in the collection
+    const collectionAssets = await umi.rpc.getAssetsByGroup({
+      groupKey: 'collection',
+      groupValue: collectionAddress,
+      limit: 1000,
+      displayOptions: {
+        showCollectionMetadata: true
+      }
+    })
+
+    const assets = collectionAssets.items
+    
+    // Basic statistics
+    const totalAssets = assets.length
+    const uniqueOwners = new Set(assets.map(asset => asset.ownership.owner))
+      
+    // Ownership distribution
+    const ownershipCounts = {}
+    assets.forEach(asset => {
+      ownershipCounts[asset.ownership.owner] = (ownershipCounts[asset.ownership.owner] || 0) + 1
+    })
+    
+    // Top owners
+    const topOwners = Object.entries(ownershipCounts)
+      .sort(([,a], [,b]) => b - a)
+      .slice(0, 10)
+    
+    console.log('Collection Statistics:')
+    console.log(`Total assets: ${totalAssets}`)
+    console.log(`Unique owners: ${uniqueOwners.size}`)
+    console.log('Top 10 owners:', topOwners)
+    
+    return {
+      totalAssets,
+      uniqueOwners: uniqueOwners.size,
+      ownershipCounts,
+      topOwners
+    }
+  }
+
+  // Usage
+  const stats = await getCollectionStatistics('COLLECTION_ADDRESS')
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  async function getCollectionStatistics(collectionAddress) {
+    const response = await fetch('<ENDPOINT>', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'getAssetsByGroup',
+        params: {
+          groupKey: 'collection',
+          groupValue: collectionAddress,
+          limit: 1000,
+          options: {
+            showCollectionMetadata: true,
+          }
+        }
+      })
+    })
+
+    const data = await response.json()
+    const assets = data.result.items
+    
+    // Basic statistics
+    const totalAssets = assets.length
+    const uniqueOwners = new Set(assets.map(asset => asset.ownership.owner))
+      
+    // Ownership distribution
+    const ownershipCounts = {}
+    assets.forEach(asset => {
+      ownershipCounts[asset.ownership.owner] = (ownershipCounts[asset.ownership.owner] || 0) + 1
+    })
+    
+    // Top owners
+    const topOwners = Object.entries(ownershipCounts)
+      .sort(([,a], [,b]) => b - a)
+      .slice(0, 10)
+    
+    console.log('Collection Statistics:')
+    console.log(`Total assets: ${totalAssets}`)
+    console.log(`Unique owners: ${uniqueOwners.size}`)
+    console.log('Top 10 owners:', topOwners)
+    
+    return {
+      totalAssets,
+      uniqueOwners: uniqueOwners.size,
+      ownershipCounts,
+      topOwners
+    }
+  }
+
+  // Usage
+  const stats = await getCollectionStatistics('COLLECTION_ADDRESS')
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Common Use Cases
+
+- **Analytics Dashboards**: Display collection statistics and trends
+- **Collection Management**: Monitor collection health and growth
+- **Investor Tools**: Analyze collection performance and rarity
+
+## Tips and Best Practices
+
+1. **[Use pagination](/das-api/guides/pagination)** for large collections to get complete data
+2. **Cache results** to improve performance for frequent queries
+3. **Handle edge cases** like missing metadata or attributes
+4. **Normalize data** for consistent analysis across collections
+5. **Track trends** over time for meaningful insights
+
+## Further Reading
+
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Find Compressed NFTs](/das-api/guides/find-compressed-nfts) - Discover and work with compressed NFTs
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria) - Combine multiple filters for advanced queries 

src/pages/das-api/guides/find-compressed-nfts.md

@@ -0,0 +1,283 @@
+---
+title: Find Compressed NFTs
+metaTitle: Find Compressed NFTs | DAS API Guides
+description: Learn how to discover and work with compressed NFTs using the DAS API
+---
+
+# Find Compressed NFTs
+
+This guide shows you how to find and work with compressed NFTs using the DAS API. Compressed NFTs are a space-efficient way to store NFT data on Solana using Bubblegum or Bubblegum V2, and the DAS API provides special methods to handle them.
+
+## Method 1: Finding Compressed NFTs by Owner
+
+Discover compressed NFTs owned by a specific wallet:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from "@metaplex-foundation/umi"
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults"
+import { dasApi } from "@metaplex-foundation/digital-asset-standard-api"
+
+(async () => {
+  const umi = createUmi("<ENDPOINT>").use(dasApi());
+
+  // Find all NFTs owned by a specific wallet (both compressed and regular)
+  const allOwnerNfts = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    limit: 1000
+  });
+
+  // Filter by compression status
+  const compressedNfts = allOwnerNfts.items.filter(
+    (nft) => nft.compression?.compressed === true
+  );
+  const regularNfts = allOwnerNfts.items.filter(
+    (nft) => !nft.compression?.compressed
+  );
+
+  console.log(
+    `Found ${compressedNfts.length} compressed NFTs owned by wallet`
+  );
+  console.log(`Regular NFTs: ${regularNfts.length}`);
+  console.log(`Compressed NFTs: ${compressedNfts.length}`);
+  console.log(`Total NFTs: ${allOwnerNfts.items.length}`);
+})();
+
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        limit: 1000
+      }
+    })
+  });
+
+  const data = await response.json();
+  const allOwnerNfts = data.result;
+
+  // Filter by compression status
+  const compressedNfts = allOwnerNfts.items.filter(
+    (nft) => nft.compression?.compressed === true
+  );
+  const regularNfts = allOwnerNfts.items.filter(
+    (nft) => !nft.compression?.compressed
+  );
+
+  console.log(
+    `Found ${compressedNfts.length} compressed NFTs owned by wallet`
+  );
+  console.log(`Regular NFTs: ${regularNfts.length}`);
+  console.log(`Compressed NFTs: ${compressedNfts.length}`);
+  console.log(`Total NFTs: ${allOwnerNfts.items.length}`);
+})();
+
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Finding Compressed NFTs by Collection
+
+Find compressed NFTs from a specific collection:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  // Find all NFTs from a specific collection (both compressed and regular)
+  const allCollectionNfts = await umi.rpc.searchAssets({
+    grouping: [
+      'collection',
+      '<COLLECTION_ADDRESS>'
+    ],
+    limit: 1000,
+    // Optional: Display collection metadata in each asset
+    displayOptions: {
+      showCollectionMetadata: true
+    }
+  });
+
+  // Filter by compression status
+  const compressedNfts = allCollectionNfts.items.filter(
+    (nft) => nft.compression?.compressed === true
+  );
+  const regularNfts = allCollectionNfts.items.filter(
+    (nft) => !nft.compression?.compressed
+  );
+
+  console.log(
+    `Found ${compressedNfts.length} compressed NFTs in collection`
+  );
+  console.log(`Regular NFTs: ${regularNfts.length}`);
+  console.log(`Compressed NFTs: ${compressedNfts.length}`);
+  console.log(`Total NFTs: ${allCollectionNfts.items.length}`);
+})();
+
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        grouping: [
+          'collection',
+          '<COLLECTION_ADDRESS>'
+        ],
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true
+        }
+      }
+    })
+  });
+
+  const data = await response.json();
+  const allCollectionNfts = data.result;
+
+  // Filter by compression status
+  const compressedNfts = allCollectionNfts.items.filter(
+    (nft) => nft.compression?.compressed === true
+  );
+  const regularNfts = allCollectionNfts.items.filter(
+    (nft) => !nft.compression?.compressed
+  );
+
+  console.log(
+    `Found ${compressedNfts.length} compressed NFTs in collection`
+  );
+  console.log(`Regular NFTs: ${regularNfts.length}`);
+  console.log(`Compressed NFTs: ${compressedNfts.length}`);
+  console.log(`Total NFTs: ${allCollectionNfts.items.length}`);
+})();
+
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 3: Finding Compressed NFTs by Creator
+
+Discover compressed NFTs created by a specific wallet:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from "@metaplex-foundation/umi"
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults"
+import { dasApi } from "@metaplex-foundation/digital-asset-standard-api"
+
+(async () => {
+  const umi = createUmi("<ENDPOINT>").use(dasApi());
+
+  // Find all NFTs created by a specific wallet (both compressed and regular)
+  const allCreatorNfts = await umi.rpc.searchAssets({
+    creator: publicKey("CREATOR_ADDRESS"),
+    displayOptions: {
+      showCollectionMetadata: true,
+    },
+  });
+
+  // Filter by compression status
+  const compressedNfts = allCreatorNfts.items.filter(
+    (nft) => nft.compression?.compressed === true
+  );
+  const regularNfts = allCreatorNfts.items.filter(
+    (nft) => !nft.compression?.compressed
+  );
+
+  console.log(
+    `Found ${compressedNfts.length} compressed NFTs created by wallet`
+  );
+  console.log(`Creator's regular NFTs: ${regularNfts.length}`);
+  console.log(`Creator's compressed NFTs: ${compressedNfts.length}`);
+  console.log(`Creator's total NFTs: ${allCreatorNfts.items.length}`);
+})();
+
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        creatorAddress: 'CREATOR_ADDRESS',
+        options: {
+          showCollectionMetadata: true,
+        }
+      }
+    })
+  });
+
+  const data = await response.json();
+  const allCreatorNfts = data.result;
+
+  // Filter by compression status
+  const compressedNfts = allCreatorNfts.items.filter(
+    (nft) => nft.compression?.compressed === true
+  );
+  const regularNfts = allCreatorNfts.items.filter(
+    (nft) => !nft.compression?.compressed
+  );
+
+  console.log(
+    `Found ${compressedNfts.length} compressed NFTs created by wallet`
+  );
+  console.log(`Creator's regular NFTs: ${regularNfts.length}`);
+  console.log(`Creator's compressed NFTs: ${compressedNfts.length}`);
+  console.log(`Creator's total NFTs: ${allCreatorNfts.items.length}`);
+})();
+
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Tips and Best Practices
+
+1. **Use [pagination](/das-api/guides/pagination)** for large compressed NFT collections
+2. **Handle errors gracefully** when proofs are unavailable
+3. **Use appropriate display options** for compressed NFT metadata
+
+## Further Reading
+
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Get NFTs by Owner](/das-api/guides/get-nfts-by-owner) - Find all NFTs owned by a wallet
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria) - Combine multiple filters for advanced queries 

src/pages/das-api/guides/find-token-holders.md

@@ -0,0 +1,225 @@
+---
+title: Find Who Holds a Specific Token
+metaTitle: Find Token Holders | DAS API Guides
+description: Learn how to discover all wallets holding a particular token
+---
+
+This guide shows you how to find all wallets that hold a specific NFT in a collection using the DAS API. This is useful for understanding token distribution, finding whale holders, or analyzing ownership patterns.
+
+## Method 1: Using Search Assets (Recommended)
+
+The `searchAssets` method is the most efficient way to find all holders of NFTs within a collection. `getAssetsByGroup` is also a viable option, but it provides fewer filtering capabilities.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  // Find all holders of a specific NFT in a collection
+  const holders = await umi.rpc.searchAssets({
+    grouping: {
+      key: 'collection',
+      value: 'YOUR_COLLECTION_ADDRESS'
+    },
+    limit: 1000,
+    displayOptions: {
+      showCollectionMetadata: true
+    }
+  })
+
+  console.log(`Found ${holders.items.length} holders`)
+  holders.items.forEach(asset => {
+    console.log(`Owner: ${asset.ownership.owner}`)
+    console.log(`Token ID: ${asset.id}`)
+  })
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        grouping: ['collection', 'YOUR_COLLECTION_ADDRESS'],
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} assets in collection`)
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "searchAssets",
+    "params": {
+      "grouping": ["collection", "YOUR_COLLECTION_ADDRESS"],
+      "limit": 1000,
+      "options": {
+        "showCollectionMetadata": true
+      }
+    }
+  }'
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Using Get Assets By Group
+
+For collection-based NFTs, you can also use `getAssetsByGroup` to find all NFTs in a collection. It is easier to use than `searchAssets` but provides fewer options for further filtering.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<<ENDPOINT>>"
+  ).use(dasApi());
+
+  // Get all assets in a collection
+  const collectionAssets = await umi.rpc.getAssetsByGroup({
+    grouping: ["collection", "COLLECTION_ADDRESS"],
+  });
+
+  // Extract unique owners
+  const uniqueOwners = new Set();
+  collectionAssets.items.forEach((asset) => {
+    uniqueOwners.add(asset.ownership.owner);
+  });
+
+  console.log(`Found ${uniqueOwners.size} unique holders`);
+  console.log("Holders:", Array.from(uniqueOwners));
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch(
+    "<ENDPOINT>",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getAssetsByGroup",
+        params: {
+          grouping: ["collection", "COLLECTION_ADDRESS"],
+        },
+      }),
+    }
+  );
+  const collectionAssets = await response.json();
+
+  // Extract unique owners
+  const uniqueOwners = new Set();
+  collectionAssets.result.items.forEach((asset) => {
+    uniqueOwners.add(asset.ownership.owner);
+  });
+
+  console.log(`Found ${uniqueOwners.size} unique holders`);
+  console.log("Holders:", Array.from(uniqueOwners));
+})();
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 3: For Individual Tokens
+If you want to find holders of a specific individual NFT (not part of a collection), you'll need to use the NFT's specific Address in `getAsset`.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Get a specific token
+  const token = await umi.rpc.getAsset({
+    assetId: publicKey("SPECIFIC_TOKEN_ID")
+  });
+
+  console.log(`Token ${token.id} is owned by: ${token.ownership.owner}`);
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+    const response = await fetch("<ENDPOINT>", {
+        method: "POST",
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({
+          "jsonrpc": "2.0",
+          "id": 1,
+          "method": "getAsset",
+          "params": {
+            "id": "SPECIFIC_TOKEN_ID"
+          }
+        })
+    })
+})();
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Tips and Best Practices
+
+1. **Handle [Pagination](/das-api/guides/pagination)**: For large collections, always implement pagination to get all results.
+
+2. **Use [Display Options](/das-api/guides/display-options)**: Enable `showCollectionMetadata` to get additional collection information.
+
+3. **Cache Results**: Where NFT holder data doesn't change frequently, consider caching results for better performance.
+
+4. **Rate Limiting**: Be mindful of API rate limits when making multiple requests.
+
+## Related Guides
+
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts)
+- [Analyze Collection Statistics](/das-api/guides/collection-statistics)
+- [Track Asset Transfers](/das-api/guides/track-transfers)

src/pages/das-api/guides/get-collection-nfts.md

@@ -0,0 +1,287 @@
+---
+title: Get All Tokens in a Collection
+metaTitle: Get All Tokens in a Collection | DAS API Guides
+description: Learn how to retrieve all digital assets belonging to a specific collection
+---
+
+This guide shows you how to retrieve all digital assets (NFTs, tokens) that belong to a specific collection using the DAS API. This is useful for building collection explorers, analytics dashboards, or marketplace features.
+
+## Method 1: Using Get Assets By Group (Recommended)
+
+The `getAssetsByGroup` method is specifically designed to find assets that belong to a particular collection.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+// Get all assets in a specific collection
+const collectionAssets = await umi.rpc.getAssetsByGroup({
+  groupKey: 'collection',
+  groupValue: '<COLLECTION_ADDRESS>'
+})
+
+console.log(`Found ${collectionAssets.items.length} assets in collection`)
+console.log(`Total: ${collectionAssets.total} assets available`)
+
+// Process each asset
+collectionAssets.items.forEach(asset => {
+  console.log(`Asset ID: ${asset.id}`)
+  console.log(`Name: ${asset.content.metadata?.name || 'Unknown'}`)
+  console.log(`Interface: ${asset.interface}`)
+  console.log(`Owner: ${asset.ownership.owner}`)
+  console.log('---')
+})
+
+})()
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'getAssetsByGroup',
+      params: {
+        groupKey: 'collection',
+        groupValue: '<COLLECTION_ADDRESS>'
+      }
+    })
+  })
+  
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} assets in collection`)
+})()
+```
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "getAssetsByGroup",
+    "params": {
+      "groupKey": "collection",
+      "groupValue": "COLLECTION_ADDRESS"
+    }
+  }'
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Using Search Assets with Collection Filter
+
+You can also use `searchAssets` with a collection grouping for more specific queries. See [Search Assets by Criteria](/das-api/guides/search-by-criteria) for more information.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  // Search for all assets in a collection with additional filters
+  const allCollectionNfts = await umi.rpc.searchAssets({
+    grouping: ['collection', '<COLLECTION_ADDRESS>'],
+    // Optional: DAS usually returns 10.000 assets
+    limit: 1000,
+    // Optional: Display collection metadata in each asset
+    displayOptions: {
+      showCollectionMetadata: true
+    }
+  });
+
+  console.log(`Found ${allCollectionNfts.items.length} assets`)
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        grouping: ['collection', '<COLLECTION_ADDRESS>'],
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true,
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} assets`)
+})();
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 3: Sorting Collection Assets
+
+You can sort collection assets by various criteria:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  // Get collection assets sorted by creation date (newest first)
+  const newestAssets = await umi.rpc.getAssetsByGroup({
+    groupKey: 'collection',
+    groupValue: 'COLLECTION_ADDRESS',
+    limit: 1000,
+    sortBy: {
+      sortBy: 'created',
+      sortDirection: 'desc'
+    },
+    displayOptions: {
+      showCollectionMetadata: true
+    }
+  })
+
+  // Get collection assets sorted by name
+  const nameSortedAssets = await umi.rpc.getAssetsByGroup({
+    groupKey: 'collection',
+    groupValue: 'COLLECTION_ADDRESS',
+    limit: 1000,
+    sortBy: {
+      sortBy: 'name',
+      sortDirection: 'asc'
+    },
+    displayOptions: {
+      showCollectionMetadata: true
+    }
+  })
+
+  console.log('Newest assets first:')
+  newestAssets.items.slice(0, 5).forEach(asset => {
+    console.log(`${asset.content.metadata?.name} - ID: ${asset.id}`)
+  })
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  // Get collection assets sorted by creation date (newest first)
+  const newestResponse = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'getAssetsByGroup',
+      params: {
+        groupKey: 'collection',
+        groupValue: 'COLLECTION_ADDRESS',
+        limit: 1000,
+        sortBy: {
+          sortBy: 'created',
+          sortDirection: 'desc'
+        },
+        options: {
+          showCollectionMetadata: true
+        }
+      }
+    })
+  })
+
+  const newestData = await newestResponse.json()
+  const newestAssets = newestData.result
+
+  // Get collection assets sorted by name
+  const nameResponse = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'getAssetsByGroup',
+      params: {
+        groupKey: 'collection',
+        groupValue: 'COLLECTION_ADDRESS',
+        limit: 1000,
+        sortBy: {
+          sortBy: 'name',
+          sortDirection: 'asc'
+        },
+        options: {
+          showCollectionMetadata: true
+        }
+      }
+    })
+  })
+
+  const nameData = await nameResponse.json()
+  const nameSortedAssets = nameData.result
+
+  console.log('Newest assets first:')
+  newestAssets.items.slice(0, 5).forEach(asset => {
+    console.log(`${asset.content.metadata?.name} - ID: ${asset.id}`)
+  })
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Common Use Cases
+
+- **Collection Explorers**: Display all assets in a collection with filtering and sorting.
+- **Marketplace Integration**: Show available assets from a specific collection.
+- **Analytics Dashboards**: Track collection statistics and ownership distribution.
+- **Gaming Applications**: Load all assets from a game's collection.
+
+## Tips and Best Practices
+
+1. **Use [pagination](/das-api/guides/pagination)** for large collections to avoid rate limits
+2. **Cache results** when possible to improve performance
+3. **Include [display options](/das-api/guides/display-options)** to get additional metadata
+4. **Sort results** to present data in meaningful ways
+5. **Handle errors** gracefully when collection addresses are invalid
+
+## Next Steps
+
+- [Get Assets By Creator](/das-api/methods/get-assets-by-creator) - Discover all tokens created by a specific wallet
+- [Get All Tokens in a Wallet](/das-api/guides/get-wallet-tokens) - See everything a wallet owns
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria) - Combine multiple filters for advanced queries

src/pages/das-api/guides/get-fungible-assets.md

@@ -0,0 +1,276 @@
+---
+title: Get Fungible Assets by Owner
+metaTitle: Get Fungible Assets | DAS API Guides
+description: Learn how to retrieve all fungible tokens owned by a specific wallet
+---
+
+This guide shows you how to retrieve all fungible tokens (like SPL tokens, SOL, etc.) owned by a specific wallet address using the DAS API.
+
+## Method 1: Using Search Assets with Interface Filter (Recommended)
+
+The most effective way to get fungible assets is using `searchAssets` with the `FungibleToken` interface filter. It only returns fungible assets, so you don't need to filter for them.
+
+While this method is the most effective, it's not supported by all DAS API Providers currently.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  // Get all fungible assets owned by a wallet
+  const fungibleTokens = await umi.rpc.searchAssets({
+    owner: publicKey('WALLET_ADDRESS'),
+    interface: 'FungibleToken',
+    limit: 1000,
+    displayOptions: {
+      showFungible: true
+    }
+  })
+
+  console.log(`Found ${fungibleTokens.items.length} fungible assets`)
+  fungibleTokens.items.forEach(asset => {
+    console.log(`Token: ${asset.id}`)
+    console.log(`Supply: ${asset.supply}`)
+    console.log(`Name: ${asset.content.metadata?.name || 'Unknown'}`)
+    console.log(`Symbol: ${asset.content.metadata?.symbol || 'Unknown'}`)
+  })
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        interface: 'FungibleToken',
+        limit: 10000,
+        options: {
+          showFungible: true
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} fungible assets`)
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "searchAssets",
+    "params": {
+      "ownerAddress": "WALLET_ADDRESS",
+      "interface": "FungibleToken",
+      "limit": 10000,
+      "options": {
+        "showFungible": true
+      }
+    }
+  }'
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Using Get Assets By Owner with Filtering
+
+You can also use `getAssetsByOwner` and filter the results client-side:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+  // Get all assets and filter for fungible ones
+  const allAssets = await umi.rpc.getAssetsByOwner({
+    owner: publicKey('WALLET_ADDRESS'),
+    limit: 10000,
+    displayOptions: {
+      showFungible: true
+    }
+  })
+
+  // Filter for fungible assets
+  const fungibleTokens = allAssets.items.filter(
+    (asset) => asset.interface === 'FungibleToken',
+  )
+
+  console.log(
+    `Found ${fungibleTokens.length} fungible assets out of ${allAssets.items.length} total assets`,
+  )
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'getAssetsByOwner',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        options: {
+          showFungible: true
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  const allAssets = data.result
+
+  // Filter for fungible assets
+  const FungibleTokens = allAssets.items.filter(asset => 
+    asset.interface === 'FungibleToken'
+  )
+
+  console.log(`Found ${FungibleTokens.length} fungible assets out of ${allAssets.items.length} total assets`)
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 3: Filtering by Token Properties
+
+You can filter fungible tokens by various properties:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+// Get tokens with specific supply range
+const tokensBySupply = await umi.rpc.searchAssets({
+  owner: publicKey('WALLET_ADDRESS'),
+  interface: 'FungibleToken',
+  supply: 1000000, // Tokens with supply >= 1M
+  limit: 1000,
+  displayOptions: {
+    showFungible: true
+  }
+})
+
+// Get tokens by creator
+const creatorTokens = await umi.rpc.searchAssets({
+  owner: publicKey('WALLET_ADDRESS'),
+  interface: 'FungibleToken',
+  creatorAddress: 'CREATOR_ADDRESS',
+  limit: 1000,
+  displayOptions: {
+    showFungible: true
+  }
+})
+
+console.log(`Tokens by supply: ${tokensBySupply.items.length}`)
+console.log(`Creator tokens: ${creatorTokens.items.length}`)
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+```javascript
+(async () => {
+  // Get tokens with specific supply range
+  const tokensBySupplyResponse = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        interface: 'FungibleToken',
+        supply: 1000000, // Tokens with supply >= 1M
+        limit: 1000,
+        options: {
+          showFungible: true
+        }
+      }
+    })
+  })
+
+  const tokensBySupplyData = await tokensBySupplyResponse.json()
+  const tokensBySupply = tokensBySupplyData.result
+
+  // Get tokens by creator
+  const creatorResponse = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        interface: 'FungibleToken',
+        creatorAddress: 'CREATOR_ADDRESS',
+        limit: 1000,
+        options: {
+          showFungible: true
+        }
+      }
+    })
+  })
+
+  const creatorData = await creatorResponse.json()
+  const creatorTokens = creatorData.result
+
+  console.log(`Tokens by supply: ${tokensBySupply.items.length}`)
+  console.log(`Creator tokens: ${creatorTokens.items.length}`)
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Tips and Best Practices
+
+1. **Use Interface Filter**: see [Search Assets by Criteria](/das-api/guides/search-by-criteria) for more information.
+2. **Enable Show Fungible**: Use `showFungible: true` in display options to get complete token information as shown in [Display Options](/das-api/guides/display-options).
+3. **Consider Decimals**: Check the `decimals` field to properly format token amounts.
+4. **Cache Results**: Token balances change frequently, but token metadata is relatively stable.
+
+## Related Guides
+
+- [Get All Tokens in a Wallet](/das-api/guides/get-wallet-tokens)
+- [Get NFTs by Owner](/das-api/guides/get-nfts-by-owner)
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria)
+- [Analyze Collection Statistics](/das-api/guides/collection-statistics) 

src/pages/das-api/guides/get-nfts-by-owner.md

@@ -0,0 +1,255 @@
+---
+title: Get NFTs by Owner
+metaTitle: Get NFTs by Owner | DAS API Guides
+description: Learn how to retrieve all non-fungible tokens owned by a specific wallet
+---
+
+# Get NFTs by Owner
+
+This guide shows you how to retrieve all non-fungible tokens (NFTs) owned by a specific wallet address using the DAS API. This is useful for building NFT galleries, portfolio trackers, or marketplace features.
+
+## Method 1: Using Get Assets By Owner with Interface Filter (Recommended)
+
+The `getAssetsByOwner` method combined with interface filtering is the most efficient way to get NFTs owned by a specific wallet, it only returns the NFTs that apply to the interface filter, e.g. `MplCoreAsset` would not return compressed NFTs.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from "@metaplex-foundation/umi";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { dasApi } from "@metaplex-foundation/digital-asset-standard-api";
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+  console.log("umi.rpc.getAssetsByOwner");
+  // Get all NFTs owned by a specific wallet
+  const ownerNfts = await umi.rpc.getAssetsByOwner({
+    owner: publicKey("WALLET_ADDRESS"),
+    interface: "MplCoreAsset", //optional, without this you will get all assets owned by the wallet
+    displayOptions: {
+      showCollectionMetadata: true,
+      showFungible: false, // to exclude fungible tokens
+    },
+  });
+
+  console.log(`Found ${ownerNfts.items.length} NFTs owned by this wallet`);
+  console.log(`Total assets: ${ownerNfts.total}`);
+
+  // Process each NFT
+  ownerNfts.items.forEach((nft) => {
+    console.log(`NFT ID: ${nft.id}`);
+    console.log(`Name: ${nft.content.metadata?.name || "Unknown"}`);
+    console.log(
+      `Collection: ${
+        nft.grouping?.find((g) => g.group_key === "collection")?.group_value ||
+        "None"
+      }`
+    );
+    console.log("---");
+  });
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch("<ENDPOINT>", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getAssetsByOwner",
+      params: {
+        ownerAddress: "WALLET_ADDRESS",
+        options: {
+          showCollectionMetadata: true,
+          showFungible: false, // to exclude fungible tokens
+        },
+      },
+    }),
+  });
+
+  const data = await response.json();
+  console.log(`Found ${data.result.items.length} NFTs`);
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "getAssetsByOwner",
+    "params": {
+      "ownerAddress": "WALLET_ADDRESS",
+      "options": {
+        "showCollectionMetadata": true,
+        "showFungible": false
+      }
+    }
+  }'
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Using Search Assets with Owner and Interface Filter
+
+You can use `searchAssets` to get more specific results with additional filters like interface to get only `MplCoreAsset`s.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+```typescript
+import { publicKey } from "@metaplex-foundation/umi";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { dasApi } from "@metaplex-foundation/digital-asset-standard-api";
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Search for NFTs owned by a specific wallet
+  const ownerNfts = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    limit: 1000,
+    interface: "MplCoreAsset",
+    displayOptions: {
+      showCollectionMetadata: true,
+    },
+  });
+
+  console.log(`Found ${ownerNfts.items.length} Core Assets`);
+})();
+
+
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+```javascript
+(async () => {
+  const response = await fetch("<ENDPOINT>", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "searchAssets",
+      params: {
+        ownerAddress: "WALLET_ADDRESS",
+        interface: "MplCoreAsset",
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true,
+        },
+      },
+    }),
+  });
+
+  const data = await response.json();
+  console.log(`Found ${data.result.items.length} Core Assets`);
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 3 – Filter NFTs by Collection
+
+You can filter NFTs by specific collections in addition to the wallet address—for example when looking for NFTs from your own collection.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+```typescript
+import { publicKey } from "@metaplex-foundation/umi";
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import { dasApi } from "@metaplex-foundation/digital-asset-standard-api";
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Get NFTs from a specific collection owned by this wallet
+  const collectionNfts = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    grouping: ["collection", "COLLECTION_ADDRESS"],
+    limit: 1000,
+    displayOptions: {
+      showCollectionMetadata: true,
+      showFungible: false,
+    },
+  });
+
+  console.log(`Found ${collectionNfts.items.length} NFTs from this collection`);
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+```javascript
+(async () => {
+  const response = await fetch(
+    "<ENDPOINT>",
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "searchAssets",
+        params: {
+          ownerAddress: "WALLET_ADDRESS",
+          grouping: [
+            "collection",
+            "COLLECTION_ADDRESS",
+          ],
+          options: {
+            showCollectionMetadata: true,
+          },
+        },
+      }),
+    }
+  );
+
+  const data = await response.json();
+  console.log(`Found ${data.result.items.length} NFTs from this collection in this wallet`);
+})();
+
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Common Use Cases
+
+- **NFT Galleries**: Display all NFTs owned by a user
+- **Portfolio Trackers**: Monitor NFT holdings
+- **Marketplace Integration**: Show user's NFT inventory
+- **Collection Management**: Organize NFTs by collections
+- **Gaming Applications**: Load user's NFT game assets
+
+## Tips and Best Practices
+
+1. **Use interface filtering** to get only NFTs (e.g. exclude fungible tokens)
+2. **Implement [pagination](/das-api/guides/pagination)** for wallets with many NFTs
+3. **Cache results** to improve performance for frequent queries
+4. **Include [display options](/das-api/guides/display-options)** to get additional metadata
+5. **Sort results** to present data in meaningful ways
+6. **Filter by collections** to focus on specific NFT types
+
+## Further Reading
+
+- [Get Assets By Creator](/das-api/methods/get-assets-by-creator) - Discover all tokens created by a specific address
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria) - Combine multiple filters for advanced queries 

src/pages/das-api/guides/get-wallet-tokens.md

@@ -0,0 +1,177 @@
+---
+title: Get All Tokens in a Wallet
+metaTitle: Get Wallet Tokens | DAS API Guides
+description: Learn how to retrieve all tokens owned by a specific wallet
+---
+
+This guide shows you how to retrieve all tokens (NFTs, fungible tokens, and other digital assets) owned by a specific wallet address using the DAS API.
+
+## Method 1: Using Get Assets By Owner (Recommended)
+
+The `getAssetsByOwner` method is the most direct way to get all tokens owned by a wallet.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Get all tokens owned by a wallet
+  const walletTokens = await umi.rpc.getAssetsByOwner({
+    owner: publicKey("WALLET_ADDRESS"),
+    displayOptions: {
+      showCollectionMetadata: true,
+      showFungible: true,
+    },
+  });
+
+  console.log(`Found ${walletTokens.items.length} tokens`);
+  walletTokens.items.forEach((token) => {
+    console.log(`Token: ${token.id}`);
+    console.log(`Interface: ${token.interface}`);
+    console.log(`Name: ${token.content.metadata?.name || "Unknown"}`);
+  });
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch("<ENDPOINT>", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getAssetsByOwner",
+      params: {
+        ownerAddress: "WALLET_ADDRESS",
+        options: {
+          showCollectionMetadata: true,
+          showFungible: true,
+        },
+      },
+    }),
+  });
+
+  const data = await response.json();
+  console.log(`Found ${data.result.items.length} tokens`);
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "getAssetsByOwner",
+    "params": {
+      "ownerAddress": "WALLET_ADDRESS",
+      "options": {
+        "showCollectionMetadata": true,
+        "showFungible": true
+      }
+    }
+  }'
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Using Search Assets with Owner Filter
+
+You can also use `searchAssets` with an owner filter for more specific queries. This method is not supported by all DAS API Providers.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Search for all assets owned by a specific wallet
+  const walletAssets = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    limit: 1000,
+    displayOptions: {
+      showCollectionMetadata: true,
+      showFungible: true,
+    },
+  });
+
+  console.log(`Found ${walletAssets.items.length} assets`);
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch("<ENDPOINT>", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "searchAssets",
+      params: {
+        ownerAddress: "WALLET_ADDRESS",
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true,
+          showFungible: true,
+        },
+      },
+    }),
+  });
+
+  const data = await response.json();
+  console.log(`Found ${data.result.items.length} assets`);
+})();
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Tips and Best Practices
+
+1. **Use [Display Options](/das-api/guides/display-options)**: Enable `showCollectionMetadata` and `showFungible` or other options like `showInscription` to get complete token information.
+
+2. **Handle [Pagination](/das-api/guides/pagination)**: For wallets with many tokens, always implement pagination.
+
+3. **Filter by Interface**: Use the `interface` parameter to get specific token types.
+
+4. **Cache Results**: Wallet contents don't change frequently, so consider caching for better performance.
+
+5. **Rate Limiting**: Be mindful of API rate limits when making multiple requests.
+
+## Related Guides
+
+- [Get Fungible Assets by Owner](/das-api/guides/get-fungible-assets)
+- [Get NFTs by Owner](/das-api/guides/get-nfts-by-owner)
+- [Get Assets by Owner and Collection](/das-api/guides/owner-and-collection)
+- [Analyze Collection Statistics](/das-api/guides/collection-statistics)

src/pages/das-api/guides/index.md

@@ -0,0 +1,49 @@
+---
+title: Guides
+metaTitle: Guides | DAS API
+description: Practical guides for common DAS API use cases
+---
+
+# DAS API Guides
+
+Welcome to the DAS API guides! These practical examples will help you solve common use cases when working with digital assets on Solana.
+
+## Getting Started
+
+- [Getting Started with DAS API](/das-api/getting-started) - Learn the basics of using the DAS API
+- [Display Options](/das-api/display-options) - Understand how to control response data
+- [Pagination](/das-api/guides/pagination) - Learn how to efficiently paginate through large datasets
+
+## Common Use Cases
+
+### Asset Discovery
+- [Find Who Holds a Specific Token](/das-api/guides/find-token-holders) - Discover all wallets holding a particular token
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets belonging to a specific collection
+
+### Wallet Analysis
+- [Get All Tokens in a Wallet](/das-api/guides/get-wallet-tokens) - See everything a wallet owns
+- [Get Fungible Assets by Owner](/das-api/guides/get-fungible-assets) - Find all fungible tokens in a wallet
+- [Get NFTs by Owner](/das-api/guides/get-nfts-by-owner) - Retrieve only non-fungible tokens from a wallet
+
+### Advanced Queries
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria) - Combine multiple filters to find specific assets
+- [Get Assets by Owner and Collection](/das-api/guides/owner-and-collection) - Find tokens from a specific collection owned by a wallet
+- [Find Compressed NFTs](/das-api/guides/find-compressed-nfts) - Discover compressed NFTs and their proofs
+
+### Collection Management
+- [Analyze Collection Statistics](/das-api/guides/collection-statistics) - Get insights about collection distribution and ownership
+
+## Code Examples
+
+All guides include practical code examples using:
+- **UMI** - Modern TypeScript SDK
+- **JavaScript** - Direct API calls
+- **cURL** - Command line examples
+
+## Need Help?
+
+If you can't find what you're looking for, check out:
+- [API Methods](/das-api/methods) - Complete method reference
+- [Core Extension](/das-api/core-extension) - Advanced SDK features
+- [DAS API UMI typedoc](https://digital-asset-standard-api-js-docs.vercel.app) - UMI typedoc for the DAS API
+- [GitHub Repository](https://github.com/metaplex-foundation/digital-asset-standard-api) - Source code and issues 

src/pages/das-api/guides/owner-and-collection.md

@@ -0,0 +1,124 @@
+---
+title: Get Assets by Owner and Collection
+metaTitle: Get Assets by Owner and Collection | DAS API Guides
+description: Learn how to find digital assets from a specific collection owned by a particular wallet
+---
+
+# Get Assets by Owner and Collection
+
+This guide shows you how to find digital assets that belong to a specific collection and are owned by a particular wallet address. This is useful for building collection-specific portfolio views, marketplace features, or analytics tools.
+
+## Using Search Assets with Owner and Collection Grouping
+
+The `searchAssets` method allows you to combine owner and collection filters for precise results.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Find assets from a specific collection owned by a wallet
+  const collectionAssets = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    grouping: ["collection", "COLLECTION_ADDRESS"],
+    limit: 1000,
+    displayOptions: {
+      showCollectionMetadata: true,
+    }
+  })
+
+  console.log(`Found ${collectionAssets.items.length} assets from collection owned by wallet`)
+  console.log(`Total available: ${collectionAssets.total}`)
+
+  // Process each asset
+  collectionAssets.items.forEach(asset => {
+    console.log(`Asset ID: ${asset.id}`)
+    console.log(`Name: ${asset.content.metadata?.name || 'Unknown'}`)
+    console.log(`Interface: ${asset.interface}`)
+    console.log('---')
+  })
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        grouping: ['collection', 'COLLECTION_ADDRESS'],
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} assets from collection owned by wallet`)
+})();
+```
+
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "searchAssets",
+    "params": {
+      "ownerAddress": "WALLET_ADDRESS",
+      "grouping": ["collection", "COLLECTION_ADDRESS"],
+      "limit": 1000,
+      "options": {
+        "showCollectionMetadata": true
+      }
+    }
+  }'
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Common Use Cases
+
+- **Collection Portfolio**: Display all assets from a specific collection owned by a user
+- **Marketplace Integration**: Show available assets from a collection in a user's wallet
+- **Collection Analytics**: Analyze holdings within specific collections
+- **Trading Tools**: Track collection holdings for trading strategies
+
+## Tips and Best Practices
+
+1. **Use [Pagination](/das-api/guides/pagination)** for large datasets
+2. **Include [Display Options](/das-api/guides/display-options)** to get additional metadata
+3. **Sort results** to present data in meaningful ways
+4. **Handle empty results** gracefully when collections are empty
+5. **Verify collection addresses** before querying
+
+## Further Reading
+
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Get NFTs by Owner](/das-api/guides/get-nfts-by-owner) - Find all NFTs owned by a wallet
+- [Search Assets by Multiple Criteria](/das-api/guides/search-by-criteria) - Combine multiple filters for advanced queries 

src/pages/das-api/guides/pagination.md

@@ -0,0 +1,318 @@
+---
+title: Paginating DAS API Requests
+metaTitle: Pagination | DAS API
+description: Learn how to paginate DAS API Requests efficiently
+---
+
+The Digital Asset Standard (DAS) API usually has a limit of 10,000 records per request. When you need to retrieve more data, pagination becomes essential. This guide covers the available pagination methods and best practices for implementing them efficiently.
+
+## Understanding Sort Options
+
+Before diving into pagination, it's important to understand the available sorting options as they affect how you'll paginate through results:
+
+- `id` (Default): Sorts assets by their binary ID
+- `created`: Sorts by creation timestamp
+- `recentAction`: Sorts by last update timestamp
+- `none`: No sorting applied (not recommended for pagination)
+
+In addition to the sorting options, you can also use the `sortDirection` parameters `asc` or `desc` to sort the results in ascending or descending order.
+
+## Pagination Methods
+
+## Page-Based Pagination (Recommended for Beginners)
+
+Page-based pagination is the easiest method to implement and understand. It's perfect for beginners and most common use cases.
+
+### How it works
+
+- Specify a page number and items per page
+- Navigate through results by incrementing the page number
+
+### Key parameters
+
+- `page`: The current page number (starts at 1)
+- `limit`: Number of items per page (usually max 10,000)
+- `sortBy`: Sorting option
+
+### Considerations
+
+- Simple to implement and understand
+- Works fine for most common use cases
+- Performance may degrade with large page numbers
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+async function getAllAssetsByPage(collectionAddress: string) {
+  const limit = 1000
+  let page = 1
+  let allAssets: any[] = []
+  let hasMore = true
+
+  while (hasMore) {
+    console.log(`Fetching page ${page}...`)
+    
+    const assets = await umi.rpc.getAssetsByGroup({
+      groupKey: 'collection',
+      groupValue: collectionAddress,
+      limit: limit,
+      page: page,
+      sortBy: {
+        sortBy: 'created',
+        sortDirection: 'desc'
+      }
+    })
+
+    if (assets.items.length === 0) {
+      hasMore = false
+    } else {
+      allAssets = [...allAssets, ...assets.items]
+      page++
+      
+      // Safety check to prevent infinite loops
+      if (page > 100) {
+        console.log('Reached maximum page limit')
+        break
+      }
+    }
+  }
+
+  console.log(`Total assets retrieved: ${allAssets.length}`)
+  return allAssets
+}
+
+// Usage
+const collectionAssets = await getAllAssetsByPage('J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w')
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+{% totem %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+const url = '<ENDPOINT>'
+
+async function getAllAssetsByPage(collectionAddress) {
+  let page = 1
+  let allAssets = []
+  let hasMore = true
+
+  while (hasMore) {
+    console.log(`Fetching page ${page}...`)
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 'my-id',
+        method: 'getAssetsByGroup',
+        params: {
+          groupKey: 'collection',
+          groupValue: collectionAddress,
+          page: page,
+          limit: 1000,
+          sortBy: { sortBy: 'created', sortDirection: 'desc' },
+        },
+      }),
+    })
+
+    const { result } = await response.json()
+    
+    if (result.items.length === 0) {
+      hasMore = false
+    } else {
+      allAssets = [...allAssets, ...result.items]
+      page++
+      
+      // Safety check
+      if (page > 100) {
+        console.log('Reached maximum page limit')
+        break
+      }
+    }
+  }
+
+  console.log(`Total assets retrieved: ${allAssets.length}`)
+  return allAssets
+}
+
+// Usage
+const collectionAssets = await getAllAssetsByPage('J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w')
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Cursor-Based Pagination (Recommended for Advanced Users)
+
+For larger datasets or when performance is critical, cursor-based pagination offers better efficiency and is the recommended approach for production applications.
+
+### How it works
+
+- Uses a cursor string to track position
+- Cursor value is returned with each response
+- Pass the cursor to the next request to get the next page
+- Perfect for sequential data traversal
+
+### Key parameters
+
+- `cursor`: Position marker for the next set of results
+- `limit`: Number of items per page (max 10,000)
+- `sortBy`: Must be set to `id` for cursor-based pagination
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+const umi = createUmi('<ENDPOINT>').use(dasApi())
+
+async function getAllAssetsByCursor(collectionAddress: string) {
+  const limit = 1000
+  let allAssets: any[] = []
+  let cursor: string | undefined
+
+  do {
+    console.log(`Fetching batch with cursor: ${cursor || 'initial'}`)
+    
+    const response = await umi.rpc.searchAssets({
+      grouping: {
+        key: 'collection',
+        value: collectionAddress
+      },
+      limit: limit,
+      cursor: cursor,
+      sortBy: {
+        sortBy: 'id',
+        sortDirection: 'asc'
+      }
+    })
+
+    allAssets = [...allAssets, ...response.items]
+    cursor = response.cursor
+    
+    console.log(`Fetched ${response.items.length} items, total: ${allAssets.length}`)
+    
+  } while (cursor !== undefined)
+
+  console.log(`Total assets retrieved: ${allAssets.length}`)
+  return allAssets
+}
+
+// Usage
+const collectionAssets = await getAllAssetsByCursor('COLLECTION_ADDRESS')
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+{% totem %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+const url = '<ENDPOINT>'
+
+async function getAllAssetsByCursor(collectionAddress) {
+  let allAssets = []
+  let cursor
+
+  do {
+    console.log(`Fetching batch with cursor: ${cursor || 'initial'}`)
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 'my-id',
+        method: 'searchAssets',
+        params: {
+          grouping: ['collection', collectionAddress],
+          limit: 1000,
+          cursor: cursor,
+          sortBy: { sortBy: 'id', sortDirection: 'asc' },
+        },
+      }),
+    })
+
+    const { result } = await response.json()
+    
+    allAssets = [...allAssets, ...result.items]
+    cursor = result.cursor
+    
+    console.log(`Fetched ${result.items.length} items, total: ${allAssets.length}`)
+    
+  } while (cursor !== undefined)
+
+  console.log(`Total assets retrieved: ${allAssets.length}`)
+  return allAssets
+}
+
+// Usage
+const collectionAssets = await getAllAssetsByCursor('COLLECTION_ADDRESS')
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+## Performance Comparison
+
+| Method | Complexity | Performance | Use Case |
+|--------|------------|-------------|----------|
+| Page-based | Low | Good for small datasets | Beginners, simple applications |
+| Cursor-based | Medium | Excellent | Production applications, large datasets |
+| Range-based | High | Excellent | Advanced queries, parallel processing |
+
+## Best Practices
+
+### Choose the Right Method
+- **Use page-based pagination** for simple use cases and beginners
+- **Use cursor-based pagination** for production applications and large collections
+- **Use range-based pagination** for advanced querying patterns
+
+### Error Handling
+- Always check for empty result sets
+- Implement retry logic for failed requests
+- Handle rate limits appropriately
+- Add safety checks to prevent infinite loops
+
+### Performance Optimization
+- Keep track of the last processed item
+- Implement proper caching strategies, but keep in mind that data, especially proofs can change quickly
+- Use appropriate sorting methods
+- Consider implementing checkpoints for long-running operations
+
+### Data Consistency
+- Always use sorting when paginating
+- Maintain consistent sort parameters between requests
+
+## Conclusion
+
+Choosing the right pagination strategy depends on your specific use case:
+
+- **For beginners and simple applications**: Use page-based pagination
+- **For production applications**: Use cursor-based pagination
+- **For advanced use cases**: Use range-based pagination
+
+Cursor-based pagination is generally the best choice for most applications as it provides excellent performance and is relatively simple to implement. Page-based pagination is perfect for learning and simple use cases, while range-based pagination offers maximum flexibility for advanced scenarios.
+
+## Further Reading
+
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Search Assets by Criteria](/das-api/guides/search-by-criteria) - Advanced search and filtering
+- [Find Compressed NFTs](/das-api/guides/find-compressed-nfts) - Working with compressed NFTs

src/pages/das-api/guides/search-by-criteria.md

@@ -0,0 +1,256 @@
+---
+title: Search Assets by Multiple Criteria
+metaTitle: Search Assets by Multiple Criteria | DAS API Guides
+description: Learn how to combine multiple filters to find specific digital assets
+---
+
+This guide shows you how to use the DAS API's `searchAssets` method to find digital assets using multiple filters and criteria. This powerful method allows you to combine various parameters to create complex queries for finding specific assets.
+
+## Method 1: Basic Multi-Criteria Search
+
+The `searchAssets` method lets you combine multiple filters—for example, to find assets owned by a given wallet and created by a particular creator.
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Search for assets with multiple criteria
+  const searchResults = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    creator: publicKey("CREATOR_ADDRESS"),
+    limit: 1000,
+    displayOptions: {
+      showCollectionMetadata: true,
+    },
+  });
+
+  console.log(`Found ${searchResults.items.length} assets matching criteria`);
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+    const response = await fetch('<ENDPOINT>', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'searchAssets',
+        params: {
+          ownerAddress: 'WALLET_ADDRESS',
+          creatorAddress: 'CREATOR_ADDRESS',
+          limit: 1000,
+          options: {
+            showCollectionMetadata: true,
+          }
+        },
+      }),
+    }
+  );
+
+  const data = await response.json();
+  console.log(`Found ${data.result.items.length} assets`);
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="cURL Example" %}
+```bash
+curl -X POST <ENDPOINT> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "searchAssets",
+    "params": {
+      "ownerAddress": "WALLET_ADDRESS",
+      "creatorAddress": "CREATOR_ADDRESS",
+      "limit": 1000,
+      "options": {
+        "showCollectionMetadata": true,
+      }
+    }
+  }'
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 2: Collection and Owner Search
+
+Find assets from a specific collection owned by a particular wallet:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+  const umi = createUmi(
+    "<ENDPOINT>"
+  ).use(dasApi());
+
+  // Find assets from a specific collection owned by a wallet
+  const collectionAssets = await umi.rpc.searchAssets({
+    owner: publicKey("WALLET_ADDRESS"),
+    grouping: ["collection", "COLLECTION_ADDRESS"],
+    limit: 1000,
+    displayOptions: {
+      showCollectionMetadata: true,
+    }
+  })
+
+  console.log(`Found ${collectionAssets.items.length} assets from collection owned by wallet`)
+  console.log(`Total available: ${collectionAssets.total}`)
+
+  // Process each asset
+  collectionAssets.items.forEach(asset => {
+    console.log(`Asset ID: ${asset.id}`)
+    console.log(`Name: ${asset.content.metadata?.name || 'Unknown'}`)
+    console.log(`Interface: ${asset.interface}`)
+    console.log('---')
+  })
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        grouping: ['collection', 'COLLECTION_ADDRESS'],
+        limit: 1000,
+        options: {
+          showCollectionMetadata: true
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} assets from collection owned by wallet`)
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## Method 3: Advanced Filtering with Multiple Conditions
+
+Combine filters for complex queries. For example, find NFTs that:  
+• belong to a given collection  
+• are owned by a specific wallet  
+• are **not** frozen or compressed  
+• have a verified creator  
+• are sorted by creation date (descending)  
+and include collection metadata:
+
+{% totem %}
+{% totem-accordion title="UMI Example" %}
+
+```typescript
+import { publicKey } from '@metaplex-foundation/umi'
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
+
+(async () => {
+    const umi = createUmi(
+        "<ENDPOINT>"
+      ).use(dasApi());
+  
+    // Complex search with multiple criteria
+    const complexSearch = await umi.rpc.searchAssets({
+      owner: publicKey('WALLET_ADDRESS'),
+      creator: publicKey('CREATOR_ADDRESS'),
+      grouping: ["collection", "COLLECTION_ADDRESS"],
+      frozen: false,
+      compressed: false,
+      displayOptions: {
+        showCollectionMetadata: true,
+      }
+    })
+  
+  console.log(
+    `Found ${complexSearch.items.length} assets matching complex criteria`
+  );
+})();
+```
+{% /totem-accordion %}
+{% totem-accordion title="JavaScript Example" %}
+
+```javascript
+(async () => {
+  const response = await fetch('<ENDPOINT>', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'searchAssets',
+      params: {
+        ownerAddress: 'WALLET_ADDRESS',
+        creatorAddress: 'CREATOR_ADDRESS',
+        grouping: ['collection', 'COLLECTION_ADDRESS'],
+        frozen: false,
+        compressed: false,
+        options: {
+          showCollectionMetadata: true,
+        }
+      }
+    })
+  })
+
+  const data = await response.json()
+  console.log(`Found ${data.result.items.length} assets matching complex criteria`)
+})();
+```
+{% /totem-accordion %}
+{% /totem %}
+## Tips and Best Practices
+
+1. **Start simple**: Begin with basic criteria and add complexity gradually
+2. **Use [Pagination](/das-api/guides/pagination)**: For large result sets, implement proper pagination
+3. **Cache results**: Store frequently accessed search results
+4. **Combine filters wisely**: Too many filters may return no results
+5. **Handle empty results**: Always check for empty result sets, but keep in mind that some assets may be hidden or not indexed yet
+6. **Use [Display Options](/das-api/guides/display-options)**: Include relevant display options for your use case
+7. **Sort results**: Use sorting to present data in meaningful ways
+8. **Test queries**: Verify your search criteria with known data
+
+## Next Steps
+
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Get NFTs by Owner](/das-api/guides/get-nfts-by-owner) - Find all NFTs owned by a wallet
+- [Get Assets By Creator](/das-api/methods/get-assets-by-creator) - Discover all tokens created by a specific wallet
+
+## Further Reading
+
+- [Get Assets By Creator](/das-api/methods/get-assets-by-creator) - Discover all tokens created by a specific wallet
+- [Get All Tokens in a Collection](/das-api/guides/get-collection-nfts) - Retrieve all assets from a specific collection
+- [Find Compressed NFTs](/das-api/guides/find-compressed-nfts) - Discover and work with compressed NFTs

src/pages/das-api/methods/get-asset-proof.md

@@ -13,25 +13,6 @@ Returns the merkle tree proof information for a compressed asset.
 | --------------- | :------: | ------------------------------------------ |
 | `id`            |    ✅    | The id of the asset.                       |
 
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-const assetId = publicKey('Ez6ezCMkRaUkWS5v6WVcP7uuCWiKadr3W2dHFkoZmteW');
-
-const proof = await umi.rpc.getAssetProof(assetId);
-console.log(proof);
-```
-
-{% /totem %}
-
-
 ## Playground
 
 {% apiRenderer method="getAssetProof" /%}

src/pages/das-api/methods/get-asset-proofs.md

@@ -13,28 +13,6 @@ Returns the merkle tree proof information for multiple compressed assets. This m
 | --------------- | :------: | ------------------------------------------ |
 | `ids`           |    ✅    | An array of asset ids to get proofs for.   |
 
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-const assetIds = [
-  publicKey('GGRbPQhwmo3dXBkJSAjMFc1QYTKGBt8qc11tTp3LkEKA'),
-  publicKey('ELDjRRs5Wb478K4h3B5bMPEhqFD8FvoET5ctHku5uiYi')
-];
-
-const assets = await umi.rpc.getAssetProofs(assetIds);
-console.log(assets);
-```
-
-{% /totem %}
-
-
 ## Playground
 
 {% apiRenderer method="getAssetProofs" /%}

src/pages/das-api/methods/get-asset-signatures.md

@@ -21,29 +21,6 @@ Returns the transaction signatures associated with a compressed asset. You can i
 | `cursor`        |          | The cursor of the signatures.               |
 | `sortDirection` |          | Sort direction. Can be either "asc" or "desc". |
 
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-
-const assets = await umi.rpc.getAssetSignatures({
-  assetId: publicKey('GGRbPQhwmo3dXBkJSAjMFc1QYTKGBt8qc11tTp3LkEKA'),
-  // Optional parameters
-  // limit: 10,
-  // page: 1,
-  // sortDirection: 'desc',
-});
-console.log(assets);
-```
-
-{% /totem %}
-
 ## Playground
 
 {% apiRenderer method="getAssetSignatures" /%}

src/pages/das-api/methods/get-asset.md

@@ -12,24 +12,7 @@ Returns the information of a compressed/standard asset including metadata and ow
 | Name            | Required | Description                                |
 | --------------- | :------: | ------------------------------------------ |
 | `id`            |    ✅    | The id of the asset.                       |
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-const assetId = publicKey('8TrvJBRa6Pzb9BDadqroHhWTHxaxK8Ws8r91oZ2jxaVV');
-
-const asset = await umi.rpc.getAsset(assetId);
-console.log(asset);
-```
-
-{% /totem %}
+| `options`       |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground
 

src/pages/das-api/methods/get-assets-by-authority.md

@@ -17,34 +17,7 @@ Returns the list of assets given an authority address.
 | `page`             |          | The index of the "page" to retrieve.       |
 | `before`           |          | Retrieve assets before the specified ID.   |
 | `after`            |          | Retrieve assets after the specified ID.    |
-
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-const authority = publicKey('mRdta4rc2RtsxEUDYuvKLamMZAdW6qHcwuq866Skxxv');
-
-const assets = await umi.rpc.getAssetsByAuthority(
-  { 
-    authority,
-    sortBy, // optional
-    limit, // optional
-    page, // optional
-    before, // optional
-    after, // optional
-  }
-);
-console.log(assets.items.length > 0);
-```
-
-{% /totem %}
+| `options`          |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground
 

src/pages/das-api/methods/get-assets-by-creator.md

@@ -22,29 +22,7 @@ We recommend to fetch data with `onlyVerified: true` to make sure the asset actu
 | `page`             |          | The index of the "page" to retrieve.       |
 | `before`           |          | Retrieve assets before the specified ID.   |
 | `after`            |          | Retrieve assets after the specified ID.    |
-
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-const creator = publicKey('D3XrkNZz6wx6cofot7Zohsf2KSsu2ArngNk8VqU9cTY3');
-
-const assets = await umi.rpc.getAssetsByCreator({
-    creator,
-    onlyVerified: true,
-    limit: 10,
-});
-console.log(assets.items.length > 0);
-```
-
-{% /totem %}
+| `options`          |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground
 

src/pages/das-api/methods/get-assets-by-group.md

@@ -18,26 +18,7 @@ Return the list of assets given a group (key, value) pair. For example this can
 | `page`             |          | The index of the "page" to retrieve.       |
 | `before`           |          | Retrieve assets before the specified ID.   |
 | `after`            |          | Retrieve assets after the specified ID.    |
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-
-const assets = await umi.rpc.getAssetsByGroup({
-    groupKey: 'collection',
-    groupValue: 'J2ZfLdQsaZ3GCmbucJef3cPnPwGcgjDW1SSYtMdq3L9p',
-});
-console.log(assets.items.length > 0);
-```
-
-{% /totem %}
+| `options`          |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground
 

src/pages/das-api/methods/get-assets-by-owner.md

@@ -17,27 +17,7 @@ Return the list of assets given an owner address.
 | `page`             |          | The index of the "page" to retrieve.       |
 | `before`           |          | Retrieve assets before the specified ID.   |
 | `after`            |          | Retrieve assets after the specified ID.    |
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-const owner = publicKey('N4f6zftYsuu4yT7icsjLwh4i6pB1zvvKbseHj2NmSQw');
-
-const assets = await umi.rpc.getAssetsByOwner({
-    owner,
-    limit: 10
-});
-console.log(assets.items.length > 0);
-```
-
-{% /totem %}
+| `options`          |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground
 

src/pages/das-api/methods/get-assets.md

@@ -12,27 +12,7 @@ Returns the information of multiple compressed/standard assets including their m
 | Name  | Required | Description            |
 | ----- | :------: | ---------------------- |
 | `ids` |    ✅    | An array of asset ids. |
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi'
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api'
-
-const umi = createUmi('<ENDPOINT>').use(dasApi())
-const assetIds = [
-  publicKey('GGRbPQhwmo3dXBkJSAjMFc1QYTKGBt8qc11tTp3LkEKA'),
-  publicKey('8bFQbnBrzeiYQabEJ1ghy5T7uFpqFzPjUGsVi3SzSMHB'),
-]
-
-const assets = await umi.rpc.getAssets(assetIds)
-console.log(assets)
-```
-
-{% /totem %}
+| `options` |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground
 

src/pages/das-api/methods/search-assets.md

@@ -36,25 +36,7 @@ Return the list of assets given a search criteria.
 | `before`            |          | Retrieve assets before the specified ID.   |
 | `after`             |          | Retrieve assets after the specified ID.    |
 | `jsonUri`           |          | The value for the JSON URI.  |
-
-## UMI w/ DAS SDK
-
-{% totem %}
-
-```js
-import { publicKey } from '@metaplex-foundation/umi';
-import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
-import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
-
-const umi = createUmi('<ENDPOINT>').use(dasApi());
-
-const assets = await umi.rpc.searchAssets({
-    owner: publicKey('N4f6zftYsuu4yT7icsjLwh4i6pB1zvvKbseHj2NmSQw'),
-    jsonUri: 'https://arweave.net/c9aGs5fOk7gD4wWnSvmzeqgtfxAGRgtI1jYzvl8-IVs/chiaki-violet-azure-common.json',
-});
-console.log(assets.items.length == 1);
-```
-{% /totem %}
+| `options`           |          | Display options object. See [Display Options](/das-api/display-options) for details. |
 
 ## Playground