🧹Spam NFT

Learn how to use Airstack to filter out spam NFTs and check whether an NFT is a spam or not.

Airstack provides easy-to-use NFT APIs for enriching Web3 applications with onchain and offchain NFT data from Ethereum, Base, Degen Chain, and other Airstack-supported chains.

When indexing any new token, Airstack takes into consideration contract deployer address history, and other factors to determine if the token might be spam.

Those contracts are the marked spam and can be filtered out. If you think that a given contract was incorrectly labeled as spam, please reach out to us [e-mail].

Table Of Contents

In this guide you will learn how to use Airstack to:

• Get Non-Spam NFT Balances Of Users

• Check If NFT Collection(s) Are Spam Or Not

• Show All Non-Spam NFTs

Pre-requisites

• An Airstack account

• Basic knowledge of GraphQL

Get Started

JavaScript/TypeScript/Python

If you are using JavaScript/TypeScript or Python, Install the Airstack SDK:

npm

React

npm install @airstack/airstack-react

Node

npm install @airstack/node

yarn

React

yarn add @airstack/airstack-react

Node

yarn add @airstack/node

pnpm

React

pnpm install @airstack/airstack-react

Node

pnpm install @airstack/node

pip

pip install airstack

Then, add the following snippets to your code:

React

import { init, useQuery } from "@airstack/airstack-react";

init("YOUR_AIRSTACK_API_KEY");

const query = `YOUR_QUERY`; // Replace with GraphQL Query

const Component = () => {
  const { data, loading, error } = useQuery(query);

  if (data) {
    return <p>Data: {JSON.stringify(data)}</p>;
  }

  if (loading) {
    return <p>Loading...</p>;
  }

  if (error) {
    return <p>Error: {error.message}</p>;
  }
};

Node

import { init, fetchQuery } from "@airstack/node";

init("YOUR_AIRSTACK_API_KEY");

const query = `YOUR_QUERY`; // Replace with GraphQL Query

const { data, error } = await fetchQuery(query);

console.log("data:", data);
console.log("error:", error);

Python

import asyncio
from airstack.execute_query import AirstackClient

api_client = AirstackClient(api_key="YOUR_AIRSTACK_API_KEY")

query = """YOUR_QUERY""" # Replace with GraphQL Query

async def main():
    execute_query_client = api_client.create_execute_query_object(
        query=query)

    query_response = await execute_query_client.execute_query()
    print(query_response.data)

asyncio.run(main())

Other Programming Languages

To access the Airstack APIs in other languages, you can use https://api.airstack.xyz/gql as your GraphQL endpoint.

🤖 AI Natural Language​

Airstack provides an AI solution for you to build GraphQL queries to fulfill your use case easily. You can find the AI prompt of each query in the demo's caption or title for yourself to try.

Airstack AI (Demo)

Get Non-Spam NFT Balances Of User(s)

Fetching

First, you can fetch the NFT balances of user(s) and show each NFT whether they are a spam or not using the token.isSpam field from the TokenBalances API.

With the query below, provide an array of users' 0x addresses, ENS domains, cb.ids, Lens profiles, Farcaster fnames/fids to owner input:

Try Demo

https://app.airstack.xyz/query/94LNTTi7Rp

Show users' NFT balances and check if each NFT is a spam or not

Code

Query

query MyQuery {
  Ethereum: TokenBalances(
    input: {
      filter: {
        owner: {
          _in: [
            "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
            "vitalik.eth"
            "lens/@vitalik"
            "fc_fname:vitalik.eth"
          ]
        }
        tokenType: { _in: [ERC1155, ERC721] }
      }
      blockchain: ethereum
    }
  ) {
    TokenBalance {
      tokenAddress
      tokenId
      tokenType
      token {
        isSpam
        name
        symbol
      }
    }
  }
  Base: TokenBalances(
    input: {
      filter: {
        owner: {
          _in: [
            "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
            "vitalik.eth"
            "lens/@vitalik"
            "fc_fname:vitalik.eth"
          ]
        }
        tokenType: { _in: [ERC1155, ERC721] }
      }
      blockchain: base
    }
  ) {
    TokenBalance {
      tokenAddress
      tokenId
      tokenType
      token {
        isSpam
        name
        symbol
      }
    }
  }
}

Response

{
  "data": {
    "Ethereum": {
      "TokenBalance": [
        {
          "tokenAddress": "0x932261f9fc8da46c4a22e31b45c4de60623848bf",
          "tokenId": "144778",
          "tokenType": "ERC721",
          "token": {
            "isSpam": false, // Not a spam NFT
            "name": "Zerion DNA 1.0",
            "symbol": "DNA"
          }
        },
        {
          "tokenAddress": "0x38f62679130121c85f28fb0c67dad560fab5688e",
          "tokenId": "0",
          "tokenType": "ERC1155",
          "token": {
            "isSpam": true, // A spam NFT
            "name": "$3,000 OP Reward",
            "symbol": "$,3000 OP Reward"
          }
        },
        // Other Ethereum NFTs
      ]
    },
    "Base": {
      "TokenBalance": [
        {
          "tokenAddress": "0x7f9f222d2c492bf3c876ecb03a148884b90020f8",
          "tokenId": "748",
          "tokenType": "ERC721",
          "token": {
            "isSpam": false,
            "name": "I Called Congress - FIT21",
            "symbol": "SWCFIT21"
          }
        },
      ],
      // Other Base NFTs
    }
  }
}

Formatting

Using the GraphQL response, you can filter out and aggregate the NFTs across Ethereum and Base by providing the response to the data input of the filterSpamNFTs function:

TypeScript

interface NFT {
  tokenAddress: string;
  tokenId: string;
  tokenType: string;
  token: {
    isSpam: boolean;
    name: string;
    symbol: string;
  };
}

interface NFTWithBlockchain extends NFT {
  blockchain: "ethereum" | "base";
}

interface TokenBalancesResponse {
  Ethereum: {
    TokenBalance?: NFT[];
  };
  Base: {
    TokenBalance?: NFT[];
  };
}

const filterSpamNFTs = (
  data: TokenBalancesResponse
): NFTWithBlockchain[] | undefined => {
  try {
    const { Ethereum, Base } = data ?? {};
    const ethNfts =
      Ethereum?.TokenBalance?.map((nft: NFT) =>
        nft?.token?.isSpam
          ? null
          : {
              ...nft,
              blockchain: "ethereum",
            }
      ) ?? [];
    const baseNfts =
      Base?.TokenBalance?.map((nft: NFT) =>
        nft?.token?.isSpam
          ? null
          : {
              ...nft,
              blockchain: "base",
            }
      ) ?? [];
    return [...ethNfts, ...baseNfts]?.filter(Boolean) as NFTWithBlockchain[];
  } catch (e) {
    console.error(e);
  }
};

JavaScript

const filterSpamNFTs = (data) => {
  try {
    const { Ethereum, Base } = data ?? {};
    const ethNfts =
      Ethereum?.TokenBalance?.map((nft) =>
        nft?.token?.isSpam
          ? null
          : {
              ...nft,
              blockchain: "ethereum",
            }
      ) ?? [];
    const baseNfts =
      Base?.TokenBalance?.map((nft) =>
        nft?.token?.isSpam
          ? null
          : {
              ...nft,
              blockchain: "base",
            }
      ) ?? [];
    return [...ethNfts, ...baseNfts]?.filter(Boolean);
  } catch (e) {
    console.error(e);
  }
};

Python

from typing import List, Dict, Any, Optional
import traceback

def filter_spam_nfts(data: Optional[Dict[str, Any]]) -> List[Dict[str, Any]]:
    try:
        ethereum = data.get('Ethereum', {}) if data else {}
        polygon = data.get('Polygon', {}) if data else {}
        base = data.get('Base', {}) if data else {}

        eth_nfts = [
            {**nft, 'blockchain': 'ethereum'} for nft in ethereum.get('TokenBalance', [])
            if nft and not nft.get('token', {}).get('isSpam')
        ]

        polygon_nfts = [
            {**nft, 'blockchain': 'polygon'} for nft in polygon.get('TokenBalance', [])
            if nft and not nft.get('token', {}).get('isSpam')
        ]

        base_nfts = [
            {**nft, 'blockchain': 'base'} for nft in base.get('TokenBalance', [])
            if nft and not nft.get('token', {}).get('isSpam')
        ]

        return [nft for nft in eth_nfts + polygon_nfts + base_nfts if nft]
    except Exception:
        error = traceback.print_exc()
        raise Exception(error)

The formatted data will combine Ethereum, Base, Degen Chain, and other Airstack-supported chains NFTs hold by the user and filtered out all spam NFTs:

[
  {
    "tokenAddress": "0x932261f9fc8da46c4a22e31b45c4de60623848bf",
    "tokenId": "144778",
    "tokenType": "ERC721",
    "token": { "isSpam": false, "name": "Zerion DNA 1.0", "symbol": "DNA" },
    "blockchain": "ethereum"
  },
  // Other Ethereum non-spam NFTs
  {
    "tokenAddress": "0x7f9f222d2c492bf3c876ecb03a148884b90020f8",
    "tokenId": "748",
    "tokenType": "ERC721",
    "token": {
      "isSpam": false,
      "name": "I Called Congress - FIT21",
      "symbol": "SWCFIT21"
    },
    "blockchain": "base"
  }
  // Other Base non-spam NFTs
]

Check If NFT Collection(s) Are Spam Or Not

You can use Airstack to check if NFT collection(s) are spam or not by using Tokens API and providing the NFT collection address(es) to address input:

Try Demo

https://app.airstack.xyz/query/yprF4nN1wf

Check if @BoredApeYachtClub, @Ethereum Name Service, and @Pudgy Penguins are spam NFTs or not

Code

Query

query MyQuery {
  Tokens(
    input: {
      filter: {
        type: { _in: [ERC1155, ERC721] }
        address: {
          _in: [
            "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D"
            "0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85"
            "0xBd3531dA5CF5857e7CfAA92426877b022e612cf8"
          ]
        }
      }
      blockchain: ethereum
    }
  ) {
    Token {
      isSpam
      address
      name
      symbol
      type
    }
  }
}

Response

{
  "data": {
    "Tokens": {
      "Token": [
        {
          "isSpam": false, // not spam NFT
          "address": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
          "name": "Ethereum Name Service",
          "symbol": "ENS",
          "type": "ERC721"
        },
        {
          "isSpam": false, // not spam NFT
          "address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
          "name": "BoredApeYachtClub",
          "symbol": "BAYC",
          "type": "ERC721"
        },
        {
          "isSpam": false, // not spam NFT
          "address": "0xbd3531da5cf5857e7cfaa92426877b022e612cf8",
          "name": "PudgyPenguins",
          "symbol": "PPG",
          "type": "ERC721"
        }
      ]
    }
  }
}

Show All Non-Spam NFTs

You can use Airstack to fetch all existing non-spam NFTs across Ethereum, Base, and Zora:

Try Demo

https://app.airstack.xyz/query/FBBLVTTfTD

Show all non-spam NFTs on Ethereum and Base

Code

Query

query MyQuery {
  Ethereum: Tokens(
    input: {
      filter: { isSpam: { _eq: false }, type: { _in: [ERC1155, ERC721] } }
      blockchain: ethereum
    }
  ) {
    Token {
      isSpam
      address
      name
      symbol
      type
    }
    pageInfo {
      hasNextPage
      hasPrevPage
      nextCursor
      prevCursor
    }
  }
  Base: Tokens(
    input: {
      filter: { isSpam: { _eq: false }, type: { _in: [ERC1155, ERC721] } }
      blockchain: base
    }
  ) {
    Token {
      isSpam
      address
      name
      symbol
      type
    }
    pageInfo {
      hasNextPage
      hasPrevPage
      nextCursor
      prevCursor
    }
  }
}

Response

{
  "data": {
    "Ethereum": {
      "Token": [
        {
          "isSpam": false,
          "address": "0x8754f54074400ce745a7ceddc928fb1b7e985ed6",
          "name": "EulerBeats",
          "symbol": "eBEATS",
          "type": "ERC1155"
        }
        // Other non-spam Ethereum NFTs
      ],
      "pageInfo": {
        "hasNextPage": true,
        "hasPrevPage": false,
        "nextCursor": "eyJMYXN0VmFsdWVzTWFwIjp7Il9pZCI6eyJWYWx1ZSI6IjEweDAwMDExOTZmMzM5NjNiMWUzYTkzODM2ODg3YTgwODBkZjM4ODg4ODgiLCJEYXRhVHlwZSI6InN0cmluZyJ9fSwiUGFnaW5hdGlvbkRpcmVjdGlvbiI6Ik5FWFQifQ==",
        "prevCursor": ""
      }
    },
    "Base": {
      "Token": [
        {
          "isSpam": false,
          "address": "0x000000000007ee3671914a485384e0f394d5b75c",
          "name": "!fundrop finale ID",
          "symbol": "FUNFINALE",
          "type": "ERC721"
        }
        // Other non-spam Base NFTs
      ],
      "pageInfo": {
        "hasNextPage": true,
        "hasPrevPage": false,
        "nextCursor": "eyJMYXN0VmFsdWVzTWFwIjp7Il9pZCI6eyJWYWx1ZSI6IjEzNzB4MDAwMTc0YTQzOWMyYzdkYjZmNWExMzEyNWE3NmE3NjdlMDJkOTgyZiIsIkRhdGFUeXBlIjoic3RyaW5nIn19LCJQYWdpbmF0aW9uRGlyZWN0aW9uIjoiTkVYVCJ9",
        "prevCursor": ""
      }
    }
  }
}

Developer Support

If you have any questions or need help regarding fetching NFT details data, please join our Airstack's Telegram group.

More Resources

• Balance Snapshots Guides

• Holder Snapshots Guides

• NFT Details

• NFT Balances

• NFT Holders

• Combinations (Common Holders)

  • Multiple ERC20s or NFTs

  • Combinations of ERC20s, NFTs, and POAPs

• Tokens In Common

  • NFTs

• Tokens API Reference

• TokenNfts API Reference