How to Get All Owners of an ERC20 Token - Moralis Web3

Are you searching for the best method to get all homeowners of an ERC20 token? If that’s the case, you then’re precisely the place it’s essential to be! In at this time’s information, we’ll present you easy methods to get sorted holders of a token in a heartbeat utilizing Moralis’ Token API. In case you instantly wish to leap straight into the code, try our ERC20 Homeowners endpoint in motion down under:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(
“https://deep-index.moralis.io/api/v2.2/erc20/0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0/homeowners?chain=eth&order=DESC”,
choices
)
.then((response) => response.json())
.then((response) => console.log(response))
.catch((err) => console.error(err));

In return for working the code above, you’ll get an array comprising all homeowners of the token in query in descending order – cryptocurrency whales first! What’s extra, the response is enriched with further information, similar to proprietor percentages, the USD worth of particular person holdings, and so on. Right here’s an instance of what it’d seem like:

{
“cursor”: “eyJhbGciOiJIUz//…”,
“web page”: 1,
“page_size”: 100,
“end result”: [
{
“balance”: “3704449652939473320142469218”,
“balance_formatted”: “3704449652.939473320142469218”,
“is_contract”: false,
“owner_address”: “0x5e3ef299fddf15eaa0432e6e66473ace8c13d908”,
“owner_address_label”: “Polygon (Matic): PoS Staking Contract”,
“usd_value”: “3489442144.205111503601074219”,
“percentage_relative_to_total_supply”: 37.044496529394735
},
//…
]
}

Getting sorted holders of a token doesn’t must be more difficult than that. Nonetheless, if you’d like a extra detailed breakdown, please try the documentation web page for our ERC20 Homeowners endpoint or be part of us on this information.

Additionally, for those who want to get all homeowners of an ERC20 token your self, don’t overlook to enroll with Moralis. You possibly can create an account free of charge, and also you’ll achieve on the spot entry to our premier suite of improvement instruments!

Overview

Figuring out the homeowners of an ERC20 token has been fairly a bothersome activity from a traditional perspective. Sometimes, this course of requires manually monitoring possession adjustments and transactions throughout numerous protocols, making a workflow that’s each time-intensive and sophisticated. Certainly, there have to be a extra environment friendly methodology, proper?

At Moralis, we got down to rework this historically tough course of right into a easy activity you possibly can full with out breaking a sweat. And that is exactly what our ERC20 Homeowners endpoint means that you can do. So, for those who’d prefer to discover the best method to get sorted holders of a token, then this learn is for you. Let’s leap straight into it by introducing Moralis!

What’s Moralis? – The Best Strategy to Get All Homeowners of an ERC20 Token

Moralis is the {industry}’s main Web3 information supplier, supplying the assets it’s essential to construct subtle dapps. In our suite of improvement instruments, you’ll discover all the things from top-tier blockchain nodes to 10+ use case-specific APIs. What’s extra, Moralis presently powers blockchain and crypto initiatives for thousands and thousands of finish customers all throughout the globe!

So, why do you have to use Moralis when constructing dapps?

One API – All of the Information: All our APIs are designed to reduce the requests it’s essential to construct dapps. This implies you get extra information with fewer API calls when working with Moralis, resulting in decrease prices and enhanced effectivity. Streamline Your Improvement Expertise: Moralis’ APIs are intuitive and absolutely cross-chain. As such, you don’t must trouble with a number of suppliers for numerous chains when utilizing our APIs, providing you with a considerably extra accessible improvement expertise. Trusted By Trade Leaders: Moralis is utilized by 100,000+ builders and trusted by {industry} leaders like MetaMask, Blockchain.com, and Opera.

Industry-leading crypto enterprises that use Moralis to get all owners of ERC20 tokens, including MetaMask, Blockchain.com, Opera, etc.

Nonetheless, that offers you an summary of Moralis. Let’s now dive a bit deeper into our Web3 API suite and discover the Token API – the very best device to get all homeowners of an ERC20 token!

Moralis’ Token API and the ERC20 Homeowners Endpoint

Moralis’ Token API is the {industry}’s #1 device for ERC20 token information, supporting each single token throughout all main chains. This consists of stablecoins, meme cash, LP tokens, and all the things in between. So, for those who’re trying to combine ERC20s into your dapps, then the Token API is the device for you!

Moralis Token API banner image with Token API as title

With the Token API, you possibly can seamlessly combine balances, costs, transfers, and way more into your dapps with out breaking a sweat. What’s extra, with our ERC20 Homeowners endpoint, you may get sorted holders of a token with a single line of code.

The ERC20 Homeowners endpoint simplifies the method of fetching correct ERC20 proprietor information right into a easy operation you possibly can full in a heartbeat. With this modern characteristic, now you can fetch the highest holders and complete provide of any token, together with possession percentages, the USD worth of particular person holdings, and extra, with ease.

So, how does it work?

Nicely, to reply the above query, let’s dive into a brief script calling our ERC20 Homeowners endpoint:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

All you need to do is exchange YOUR_API_KEY together with your Moralis API key, configure the parameters to suit your question and run the script. In return, you’ll get a response comprising an array of homeowners, together with their complete steadiness, the worth of their holdings, and way more. Right here’s an instance of what the response can seem like:

The Advantages of Moralis’ ERC20 Homeowners Endpoint

Now that you’ve familiarized your self with the ERC20 Homeowners endpoint, let’s dive a bit deeper into the advantages of this characteristic:

Fewer API Calls: Up to now, you wanted to manually monitor possession throughout the blockchain, which was a time-consuming and resource-intensive course of. By consolidating ERC20 proprietor information right into a ready-to-use endpoint, you now want far fewer API calls to get the information you want. Token Holder Perception: With the ERC20 Homeowners endpoint, you possibly can seamlessly fetch the highest holders of any token, considerably boosting transparency and the understanding of token distribution. Simplified Token Analytics: With the ERC20 Homeowners endpoint, now you can effortlessly full complicated analytics duties. This consists of figuring out distinctive holders, possession percentages, early adopters, newcomers, and so on.

Graphic art illustration - showing ERC20 tokens connected to wallet owners

3-Step Tutorial: Tips on how to Get All Homeowners of an ERC20 Token with Moralis

We’ll now stroll you thru a easy tutorial on easy methods to get sorted holders of a token utilizing Moralis’ Token API. And due to the accessibility of this industry-leading device, you’ll be capable of get the information you want in three simple steps:

Get a Moralis API KeyWrite a Script Calling the ERC20 Homeowners EndpointRun the Code

Nonetheless, earlier than we are able to get going, you need to take care of some stipulations!

Stipulations

This will likely be a JavaScript and Node.js tutorial. As such, for those who haven’t already, ensure you arrange the next earlier than persevering with:

Step 1: Get a Moralis API Key

To get a Moralis API key, it’s essential to create an account by clicking on the ”Begin for Free” button on the high proper on the Moralis homepage:

When you’re achieved organising your account, it’s essential to log in, navigate to the ”Settings” tab, scroll down, and duplicate your key:

Preserve the important thing for now. You’re going to wish it within the following step to initialize Moralis.

Step 2: Write a Script Calling the ERC20 Homeowners Endpoint

Begin by opening your most popular IDE and arrange a folder. Subsequent, open a brand new terminal and initialize a mission with the command under:

npm init

You then want to put in the required dependencies with the next terminal inputs:

npm set up node-fetch –save
npm set up moralis @moralisweb3/common-evm-utils

Subsequent, open your ”package deal.json” file and add ”sort”: ”module” to the checklist:

open your ”package.json” file and add ”type”: ”module” to the list:

You possibly can then create a brand new ”index.js” file and add the next contents:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

From right here, it’s essential to configure the code barely. First, exchange YOUR_API_KEY with the Moralis key you copied throughout step one. Subsequent, you additionally must configure question parameters to suit your question.

That’s it for the code. All that continues to be from right here is executing the script!

Step 3: Run the Code

You possibly can execute the code by opening a brand new terminal and working the command under within the root folder of the mission:

node index.js

In return, you’ll get a response containing all homeowners of the ERC20 token specified within the handle parameter. Right here’s an instance of what it’d seem like:

And that’s it; it doesn’t must be more difficult than that to get sorted holders of a token when working with Moralis!

Use Instances for Our API and the ERC20 Homeowners Endpoint

Our ERC20 Homeowners endpoint is indispensable for many builders constructing dapps associated to fungible tokens. Nonetheless, to offer you just a few examples, let’s discover three outstanding use instances for this characteristic:

Token Analytics: Token analytics platforms are web sites or functions that give customers useful perception into the efficiency of the market and particular person tokens. An excellent instance of a mission leveraging our APIs is Moralis Cash – the {industry}’s main token analytics platform.

Example project to get all owners of an ERC20 token - showing the Moralis Money platform

Portfolio Trackers: Portfolio trackers are platforms that give customers an entire overview of all their digital holdings. This sometimes consists of each ERC20s and NFTs, in addition to shares and different digital belongings. Delta is a wonderful instance of a portfolio tracker platform leveraging our APIs to maintain customers up to date about current on-chain occasions.

Get all owners of an erc20 token example project - showing a portfolio tracker and its UI

Cryptocurrency Wallets: Cryptocurrency wallets are web sites and functions for storing digital belongings. One of the best wallets additionally present options for getting, promoting, and buying and selling tokens. A outstanding instance of a supplier utilizing Moralis is MetaMask – the {industry}’s #1 cryptocurrency pockets.

Past the Token API – Exploring Moralis Additional

The Token API solely scratches the floor of what’s doable with Moralis. As such, let’s now discover some further APIs you’ll doubtless discover useful when constructing your dapps. Nonetheless, we gained’t be capable of cowl all of them on this information, which is why we’ll concentrate on the next three interfaces:

Pockets APINFT APIBlockchain API

In case you’d prefer to discover all our APIs, please go to the official Web3 API web page, which features a checklist of all out there interfaces!

Pockets API

The Pockets API is the {industry}’s #1 API for pockets information, boasting a formidable array of options, unparalleled scalability, and distinctive flexibility. It’s the right device for those who’re trying to construct your personal crypto pockets or combine pockets functionalities into your dapp!

Wallet API banner with Wallet API as title

With the Pockets API, you possibly can seamlessly fetch a pockets’s ERC20 balances, web value, transaction historical past, and way more with a single line of code. To point out you the way it works, we’ll now take a look at an instance of how straightforward it’s to fetch the ERC20 balances – with costs and metadata – of a pockets utilizing our getWalletTokenBalancesPrice() endpoint:

import Moralis from ‘moralis’;

strive {
await Moralis.begin({
apiKey: “YOUR_API_KEY”
});

const response = await Moralis.EvmApi.wallets.getWalletTokenBalancesPrice({
“chain”: “0x1”,
“handle”: “0xcB1C1FdE09f811B294172696404e88E658659905”
});

console.log(response.uncooked());
} catch (e) {
console.error(e);
}

Calling the endpoint above returns an array of all tokens the pockets holds. What’s extra, the response is enriched with costs and metadata, permitting you to, as an example, construct a portfolio view with a single endpoint:

{
“cursor”: null,
“web page”: 0,
“page_size”: 100,
“end result”: [
{
“token_address”: “0xae7ab96520de3a18e5e111b5eaab095312d7fe84”,
“symbol”: “stETH”,
“name”: “Liquid staked Ether 2.0”,
“logo”: “https://logo.moralis.io/0x1_0xae7ab96520de3a18e5e111b5eaab095312d7fe84_cd0f5053ccb543e08f65554bf642d751”,
“thumbnail”: “https://logo.moralis.io/0x1_0xae7ab96520de3a18e5e111b5eaab095312d7fe84_cd0f5053ccb543e08f65554bf642d751”,
“decimals”: 18,
“balance”: “90399378678107406”,
“possible_spam”: false,
“verified_contract”: true,
“total_supply”: “9542023372380838741270859”,
“total_supply_formatted”: “9542023.372380838741270859”,
“percentage_relative_to_total_supply”: 9.47381652195e-7,
“balance_formatted”: “0.090399378678107406”,
“usd_price”: 3611.562488280326,
“usd_price_24hr_percent_change”: 4.98306233529165,
“usd_price_24hr_usd_change”: 15.496644212196657,
“usd_value”: 326.483004997701,
“usd_value_24hr_usd_change”: 16.268851653168795,
“native_token”: false,
“portfolio_percentage”: 55.2363
},
//…
]
}

To discover different capabilities of this device, try our official Pockets API web page!

NFT API

Moralis’ NFT API is Web3’s premier interface for NFT information. This main device helps over three million NFT collections throughout all the largest chains, together with all the things from established initiatives like Nakamigos to tokens that dropped simply seconds in the past!

With the NFT API, you possibly can seamlessly fetch metadata, balances, optimized picture previews, and way more with single endpoints. As such, you possibly can construct all the things from marketplaces to Web3 video games with out breaking a sweat when utilizing the NFT API.

To spotlight the accessibility of the NFT API, we’ll now present you easy methods to fetch the steadiness of any pockets with our getWalletNFTs() endpoint:

import Moralis from ‘moralis’;

strive {
await Moralis.begin({
apiKey: “YOUR_API_KEY”
});

const response = await Moralis.EvmApi.nft.getWalletNFTs({
“chain”: “0x1”,
“handle”: “0xff3879b8a363aed92a6eaba8f61f1a96a9ec3c1e”
});

console.log(response.uncooked);
} catch (e) {
console.error(e);
}

In return for calling the endpoint above, you’ll get an array of all NFTs held by the pockets in query. Right here’s an instance of what the response may seem like:

{
“standing”: “SYNCED”,
“web page”: 1,
“page_size”: 100,
“cursor”: “eyJhbGciOiJIUzI1Ni//…”,
“end result”: [
{
“amount”: “1”,
“token_id”: “5021”,
“token_address”: “0xfff54e6fe44fd47c8814c4b1d62c924c54364ad3”,
“contract_type”: “ERC721”,
“owner_of”: “0xff3879b8a363aed92a6eaba8f61f1a96a9ec3c1e”,
“last_metadata_sync”: “2024-04-09T11:27:46.910Z”,
“last_token_uri_sync”: “2024-04-09T11:27:46.896Z”,
“metadata”: null,
“block_number”: “14647390”,
“block_number_minted”: “14647390”,
“name”: “Youtopia”,
“symbol”: “Youtopia”,
“token_hash”: “d4719eaf84eabcf443065b0a463f5886”,
“token_uri”: “http://api.youtopia-official.xyz/ipfs/5021”,
“minter_address”: “0x13f11fd2c7c7be94674651386370d02b7aac9653”,
“verified_collection”: false,
“possible_spam”: true,
“collection_logo”: “”,
“collection_banner_image”: “”
},
//…
]
}

Please try our NFT API web page to be taught extra about this interface!

Blockchain API

The Blockchain API allows you to unlock the ability of uncooked blockchain information with tempo and precision. It’s scalable, exact, and cross-chain, providing you with what it’s essential to construct all the things from block explorers to analytics instruments!

With the Blockchain API, you possibly can seamlessly fetch block information, transactions, good contract logs, and extra with single strains of code. To point out you the way it works, let’s take a look at our getBlock() endpoint, permitting you to fetch the contents of any given block:

import Moralis from ‘moralis’;

strive {
await Moralis.begin({
apiKey: “YOUR_API_KEY”
});

const response = await Moralis.EvmApi.block.getBlock({
“chain”: “0x1”,
“blockNumberOrHash”: “18541416”
});

console.log(response.uncooked);
} catch (e) {
console.error(e);
}

In return for calling the endpoint above, you’ll get the block’s hash, miner handle, fuel restrict, and extra. Right here’s an instance of what the response will seem like:

{
“timestamp”: “2023-11-10T12:02:11.000Z”,
“quantity”: “18541416”,
“hash”: “0xe9de65582d5a210f3f5703e0d7dc1daf9fbb5a0670937f5d92283a41ea1bcb2b”,
“parent_hash”: “0xb63af7df0e2639cc25c323f22359b784408a117b534dea09cfec14263ea8d4fb”,
“nonce”: “0x0000000000000000”,
“sha3_uncles”: “0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347”,
“logs_bloom”: “0x00200000410//…”,
“transactions_root”: “0x0b6895fbd7fdf9b8e0239e5be21a195c89ffae093c1c2bcdea9ad498d720003b”,
“state_root”: “0x787cc0fff225d2b6d8acef1cea33522293d134297c1f4b22819a90f157db183d”,
“receipts_root”: “0x6d7caa30f12937a232dcedda5f8bc2c973ba917a67062cedeb4ccb52c729058c”,
“miner”: “0x95222290DD7278Aa3Ddd389Cc1E1d165CC4BAfe5”,
“issue”: “0”,
“total_difficulty”: “58750003716598352816469”,
“measurement”: “7792”,
“extra_data”: “0x6265617665726275696c642e6f7267”,
“gas_limit”: “30000000”,
“gas_used”: “1372772”,
“transaction_count”: “11”,
“base_fee_per_gas”: “35229184857”,
“transactions”: [
//…
]
}

Take a look at our Blockchain API web page to be taught extra about this premier interface!

Abstract: Tips on how to Get All Homeowners of an ERC20 Token

From a traditional perspective, fetching the homeowners of an ERC20 token has been an annoying activity. It sometimes requires manually monitoring possession and transactions throughout the blockchain, which is each tedious and time-consuming. Happily, it’s now doable to bypass this completely with Moralis’ ERC20 Homeowners endpoint!

With our ERC20 Homeowners endpoint, now you can get sorted holders of a token with a single API name. Along with the homeowners, you additionally get possession percentages, the USD worth of particular person holdings, and way more inside the similar response. And with this premier characteristic, we’re lowering the obstacles to complicated information analytics, making token possession information extra accessible to everybody!

In case you favored this tutorial on easy methods to get all homeowners of an ERC20 token, take into account studying extra content material right here at Moralis. As an example, try our most up-to-date article on the very best crypto emblem API or learn to get the online value of any ERC20 pockets.

Additionally, don’t overlook which you can join with Moralis freed from cost. So, take this chance to supercharge your Web3 initiatives with streamlined information integration from Moralis!

Source link