How to get all NFT transactions by an address

A few quick reasons why you'd want to get NFT transfer history by an address:
Building an NFT activity page for all transfers/sales 
Calculating the volume of NFTs traded by an address 
While this type of data cannot be easily queried via the Ethereum API, Alchemy builds higher-level Enhanced APIs to make Web3 interactions much easier. 
In this tutorial, we'll be leveraging Alchemy's Transfers API (alchemy_getAssetTransfers) to query all NFT transfers by an address.
What happens when NFTs are transacted?
Behind the scenes, whenever an NFT undergoes an on-chain sale or swap, any associated smart contract calls will emit a standard transfer event since the asset is ultimately being transferred from one account to another. 
Since we can specifically filter for transfer events using the Transfers API, we can easily fetch NFT transactions with the right combination of filter parameters!
How to get NFT Transaction History 
In order to fetch NFT transaction history by a given address, we'll need to specify a few things in our alchemy_getAssetTransfers request:
fromAddress: where the NFT transaction originated from
*when fetching NFT transaction history originating from an address we use this*
toAddress: the NFT recipient address 
*when fetching NFT transaction history by recipient address we use this*
fromBlock: the starting time range we want to fetch NFT transactions over (defaults to latest)
toBlock : the ending time range we want to fetch NFT transactions over (defaults to latest)
category: the type of transfer events we care about, in our case we want to see NFTs which are ERC721 and ERC1155 events 
Once we've specified these inputs we can send the request!
Example: How to get NFT Transaction History Originating From An Address
To demonstrate how to get the NFT transaction history from an address we're going to walk through an example using the address 0x5c43B1eD97e52d009611D89b74fA829FE4ac56b1 and getting all NFT transaction events from it spanning block 0 to the latest.  
No-code Example
For a no-code demonstration of this request, check out Alchemy's Composer tool!​
 Follow along with any of the code examples below to make the request.
Alchemy Web3.js (Recommended)
Node Fetch
Axios
transfers_api_javascript_scripts/nft-tx-history-from-alchemyweb3.js at main · alchemyplatform/transfers_api_javascript_scripts
GitHub
NFT Tx History Github Repo
If you don't already have Alchemy Web3 installed, you can install the alchemy-web3 module to easily interact with Alchemy APIs. We highly recommend using the alchemy-web3 sdk because you also get websocket support, retries, and other benefits without the complexity!
For full documentation on alchemy-web3, check the Github repo.
​
1. Create a file.
In your current directory, create a new file called nft-tx-history-from-alchemyweb3.js

Use your favorite file browser, code editor, or just directly in the terminal using the touch command like this:
1
touch nft-tx-history-from-alchemyweb3.js
Copied!

2. Write script!
Copy and paste in the following code snippet into your new file: nft-tx-history-from-alchemyweb3.js

nft-tx-history-from-alchemyweb3.js
1
import axios from 'axios';
2
​
3
  // Address we want get NFT txs from
4
  const address = "0x5c43B1eD97e52d009611D89b74fA829FE4ac56b1";
5
​
6
  let data = JSON.stringify({
7
  "jsonrpc": "2.0",
8
  "id": 0,
9
  "method": "alchemy_getAssetTransfers",
10
  "params": [
11
    {
12
      "fromBlock": "0x0",
13
      "fromAddress": address,
14
      "excludeZeroValue":true,
15
      "category": ["erc721","erc1155"]
16
    }
17
  ]
18
  });
19
​
20
  var requestOptions = {
21
    method: 'post',
22
    headers: { 'Content-Type': 'application/json' },
23
    data: data,
24
  };
25
​
26
  const apiKey = "demo"
27
  const baseURL = `https://eth-mainnet.alchemyapi.io/v2/${apiKey}`;
28
  const axiosURL = `${baseURL}`;
29
​
30
  const res = await axios(axiosURL, requestOptions);
31
​
32
  // Print contract address and tokenId for each NFT:
33
  for (const events of res.data.result.transfers) {
34
      if (events.erc1155Metadata == null) {
35
        console.log("ERC-721 Token Minted: ID- ", events.tokenId, " Contract- ", events.rawContract.address);
36
      }
37
      else{
38
        for (const erc1155 of events.erc1155Metadata) {
39
        console.log("ERC-1155 Token Minted: ID- ", erc1155.tokenId, " Contract- ", events.rawContract.address);
40
        }
41
      }
42
  }
Copied!
​
3. Run script!
Now, on your command line, you can execute the script by calling:
1
node nft-tx-history-from-alchemyweb3.js
Copied!
If you're usingnode-fetch a lightweight, common module that brings the Fetch API to Node.js and allows us to make our HTTP requests, here's a code snipper for the request you'd make!
transfers_api_javascript_scripts/nft-tx-history-from-fetch.js at main · alchemyplatform/transfers_api_javascript_scripts
GitHub
NFT Tx History Github Repo
1. Create a file.
In your current directory, create a new file called nft-tx-history-from-fetch.js using your favorite file browser, code editor, or just directly in the terminal using the touch command like this:
1
touch nft-tx-history-from-fetch.js
Copied!
​
2. Write script!
Copy and paste in the following code snippet into your new file: nft-tx-history-from-fetch.js
nft-tx-history-from-fetch.js
1
import fetch from 'node-fetch';
2
​
3
  // Address we want get NFT txs from
4
  const address = "0x5c43B1eD97e52d009611D89b74fA829FE4ac56b1";
5
​
6
  let data = JSON.stringify({
7
  "jsonrpc": "2.0",
8
  "id": 0,
9
  "method": "alchemy_getAssetTransfers",
10
  "params": [
11
    {
12
      "fromBlock": "0x0",
13
      "fromAddress": address,
14
      "excludeZeroValue":true,
15
      "category": ["erc721","erc1155"]
16
    }
17
  ]
18
});
19
​
20
​
21
  var requestOptions = {
22
    method: 'POST',
23
    headers: { 'Content-Type': 'application/json' },
24
    body: data,
25
    redirect: 'follow'
26
  };
27
​
28
  const apiKey = "demo"
29
  const baseURL = `https://eth-mainnet.alchemyapi.io/v2/${apiKey}`;
30
  const fetchURL = `${baseURL}`;
31
​
32
  fetch(fetchURL, requestOptions)
33
    .then((res) => {
34
      return res.json()
35
    })
36
    .then((jsonResponse) => {
37
      //Print token name / asset value
38
      //console.log(jsonResponse)
39
      for (const events of jsonResponse.result.transfers) {
40
          if (events.erc1155Metadata == null) {
41
            console.log("ERC-721 Token Minted: ID- ", events.tokenId, " Contract- ", events.rawContract.address);
42
          }
43
          else{
44
            for (const erc1155 of events.erc1155Metadata) {
45
            console.log("ERC-1155 Token Minted: ID- ", erc1155.tokenId, " Contract- ", events.rawContract.address);
46
            }
47
          }
48
      }
49
    })
50
    .catch((err) => {
51
      // handle error
52
      console.error(err);
53
    });
Copied!
​
3. Run script!
Now, on your command line, you can execute the script by calling:
1
node nft-tx-history-from-fetch.js
Copied!
If you're using Javascript axios, a promise-based HTTP client for the browser and Node.js which allows us to make a raw request to the Alchemy API, here's a code snipper for the request you'd make!
transfers_api_javascript_scripts/nft-tx-history-from-axios.js at main · alchemyplatform/transfers_api_javascript_scripts
GitHub
NFT Tx History Github Repo
​
1. Create a file.
In your current directory, create a new file called nft-tx-history-from-axios.js using your favorite file browser, code editor, or just directly in the terminal using the touch command. 
1
touch nft-tx-history-from-axios.js
Copied!
​
2. Write script!
Copy and paste in the following code snippet into your new file: nft-tx-history-from-axios.js
nft-tx-history-from-axios.js
1
import axios from 'axios';
2
​
3
  let data = JSON.stringify({
4
  "jsonrpc": "2.0",
5
  "id": 0,
6
  "method": "alchemy_getAssetTransfers",
7
  "params": [
8
    {
9
      "fromBlock": "0x0",
10
      "fromAddress": "0x5c43B1eD97e52d009611D89b74fA829FE4ac56b1",
11
    }
12
  ]
13
});
14
​
15
  var requestOptions = {
16
    method: 'post',
17
    headers: { 'Content-Type': 'application/json' },
18
    data: data,
19
  };
20
​
21
  const apiKey = "demo"
22
  const baseURL = `https://eth-mainnet.alchemyapi.io/v2/${apiKey}`;
23
  const axiosURL = `${baseURL}`;
24
​
25
  axios(axiosURL, requestOptions)
26
    .then(response => console.log(JSON.stringify(response.data, null, 2)))
27
    .catch(error => console.log(error));
Copied!
​
3. Run script!
Now, on your command line, you can execute the script by calling:
1
node nft-tx-history-from-axios.js
Copied!
How to process the API response
Now that we have made a query and can see the response, let's learn how to handle the returned data.
Raw API Response:
Without parsing the response, we have a command-line print-out that looks like this:
1
{
2
  [
3
    {
4
      "blockNum": "0xc75329",
5
      "hash": "0xd89b54cb5aca6f501d43ee3363dcc892d31d1c185c9059c22d686ca0a1b93314",
6
      "from": "0x0000000000000000000000000000000000000000",
7
      "to": "0x5c43b1ed97e52d009611d89b74fa829fe4ac56b1",
8
      "value": null,
9
      "erc721TokenId": "0x0000000000000000000000000000000000000000000000000000000000000012",
10
      "erc1155Metadata": null,
11
      "tokenId": "0x0000000000000000000000000000000000000000000000000000000000000012",
12
      "asset": "BURN",
13
      "category": "erc721",
14
      "rawContract": {
15
        "value": null,
16
        "address": "0x18a808dd312736fc75eb967fc61990af726f04e4",
17
        "decimal": null
18
      }
19
    },
20
    ...
21
    {
22
      "blockNum": "0xd8315a",
23
      "hash": "0x270aa9026d69b0924341e0ce60b24182f1f2af8a4bcc752b8e65595bdeca565f",
24
      "from": "0x0000000000000000000000000000000000000000",
25
      "to": "0x5c43b1ed97e52d009611d89b74fa829fe4ac56b1",
26
      "value": null,
27
      "erc721TokenId": "0x00000000000000000000000000000000000000000000000000000000000000fb",
28
      "erc1155Metadata": null,
29
      "tokenId": "0x00000000000000000000000000000000000000000000000000000000000000fb",
30
      "asset": null,
31
      "category": "erc721",
32
      "rawContract": {
33
        "value": null,
34
        "address": "0x947600ad1ad2fadf88faf7d30193d363208fc76d",
35
        "decimal": null
36
      }
37
    }
38
  ]
39
}
Copied!
Understanding API Response:
Below are each of the components in our response. 
blockNum: the block number where an NFT transaction occurred, in hex 
hash: the transaction hash of NFT transaction
from: where the transaction originated from
to: where the NFT was received
value:  the amount of ETH transferred, should always be null in our case since we're only looking at NFT transfer events which typically only transfer the NFT and not ETH
erc721TokenId: the ERC721 token ID. null if not an ERC721 token transfer.
erc1155Metadata: a list of objects containing the ERC1155 tokenId  and value. null if not an ERC1155 transfer
tokenId: the token ID for ERC721 tokens or other NFT token standards 
asset: ETH or the token's symbol. null if not defined in the contract and not available from other sources.
rawContract
value: null since we're looking at ERC721 & ERC1155 transfer
address: NFT contract address
decimal:  null
Printing out the token type, tokenId and contract address 
There's lots of information we can pull from this response. One example you may be interested in displaying are: NFT contract standard (ERC721 or ERC1155), contractAddress, and tokenId
With our queried response saved as a JSON object, we can index through the transfers. In particular, we first access the transfers list and then iterate across a few key parameters: erc1155Metadata , tokenId, and rawContract. 
The steps we want to take are:
1.Loop through all transfers in the result
2.Check whether the returned transfer is ERC1155 or not
1.If so, loop through tokens within ERC1155
1.print tokenId and address for each
2.If not, assume transfer is ERC721
1.print tokenID of contract and address
1
  for (const events of res.data.result.transfers) {
2
      if (events.erc1155Metadata == null) {
3
        console.log("ERC-721 Token Minted: ID- ", events.tokenId, " Contract- ", events.rawContract.address);
4
      }
5
      else{
6
        for (const erc1155 of events.erc1155Metadata) {
7
        console.log("ERC-1155 Token Minted: ID- ", erc1155.tokenId, " Contract- ", events.rawContract.address);
8
        }
9
      }
10
  }
Copied!
If you followed along thus far, your response should look like the following:
1
ERC-721 Token Minted: ID-  0x000000000000000000000000000000000000000000000000000000000000034a  Contract-  0x7ecb204fed7e386386cab46a1fcb823ec5067ad5
2
ERC-721 Token Minted: ID-  0x0000000000000000000000000000000000000000000000000000000000000349  Contract-  0x7ecb204fed7e386386cab46a1fcb823ec5067ad5
3
ERC-721 Token Minted: ID-  0x0000000000000000000000000000000000000000000000000000000000000348  Contract-  0x7ecb204fed7e386386cab46a1fcb823ec5067ad5
4
ERC-721 Token Minted: ID-  0x0000000000000000000000000000000000000000000000000000000000000b6e  Contract-  0x72d47d4d24018ec9048a9b0ae226f1c525b7e794s

Copied!
And that's it! You've now learned how to fetch NFT transaction history given an address on Ethereum!

If you enjoyed this tutorial, give us a tweet @AlchemyPlatform!  
(Or give the author @crypt0zeke some love!)
Also, join our Discord server to meet other blockchain devs, builders, and entrepreneurs! 