Are you searching for the simplest method to get all house owners of an ERC20 token? In that case, then you definitely’re precisely the place you want to be! In immediately’s information, we’ll present you ways to get sorted holders of a token in a heartbeat utilizing Moralis’ Token API. When you instantly need to soar straight into the code, try our ERC20 Owners endpoint in motion down under:
import fetch from 'node-fetch';
const choices = {
methodology: 'GET',
headers: {
settle for: 'utility/json',
'X-API-Key': 'YOUR_API_KEY'
},
};
fetch(
"
choices
)
.then((response) => response.json())
.then((response) => console.log(response))
.catch((err) => console.error(err));
In return for operating the code above, you’ll get an array comprising all house owners of the token in query in descending order – cryptocurrency whales first! What’s extra, the response is enriched with further knowledge, reminiscent of proprietor percentages, the USD worth of particular person holdings, and so forth. Right here’s an instance of what it would seem like:
{
"cursor": "eyJhbGciOiJIUz//...",
"page": 1,
"page_size": 100,
"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 have to be tougher than that. Nonetheless, if you would like a extra detailed breakdown, please try the documentation web page for our ERC20 Owners endpoint or be a part of us on this information.
Additionally, if you want to get all house owners of an ERC20 token your self, don’t neglect to enroll with Moralis. You possibly can create an account without cost, and also you’ll achieve on the spot entry to our premier suite of growth instruments!
Overview
Figuring out the house owners of an ERC20 token has been fairly a bothersome activity from a standard perspective. Sometimes, this course of requires manually monitoring possession modifications 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 set out to remodel this historically troublesome course of right into a easy activity you possibly can full with out breaking a sweat. And that is exactly what our ERC20 Owners endpoint permits you to do. So, for those who’d like to discover the simplest method to get sorted holders of a token, then this learn is for you. Let’s soar straight into it by introducing Moralis!
What’s Moralis? – The Best Means to Get All Owners of an ERC20 Token
Moralis is the {industry}’s main Web3 knowledge supplier, supplying the sources you want to construct subtle dapps. In our suite of growth instruments, you’ll discover the whole lot from top-tier blockchain nodes to ten+ use case-specific APIs. What’s extra, Moralis at the moment powers blockchain and crypto initiatives for tens of millions of finish customers all throughout the globe!
So, why do you have to use Moralis when constructing dapps?
- One API – All the Knowledge: All our APIs are designed to decrease the requests you want to construct dapps. This implies you get extra knowledge with fewer API calls when working with Moralis, main to decrease prices and enhanced effectivity.
- Streamline Your Growth Expertise: Moralis’ APIs are intuitive and totally cross-chain. As such, you don’t have to hassle with a number of suppliers for numerous chains when utilizing our APIs, providing you with a considerably extra accessible growth expertise.
- Trusted By Trade Leaders: Moralis is utilized by 100,000+ builders and trusted by {industry} leaders like MetaMask, Blockchain.com, and Opera.
Nonetheless, that provides you an overview of Moralis. Let’s now dive a bit deeper into our Web3 API suite and discover the Token API – the perfect software to get all house owners of an ERC20 token!
Moralis’ Token API and the ERC20 Owners Endpoint
Moralis’ Token API is the {industry}’s #1 software for ERC20 token knowledge, supporting each single token throughout all main chains. This contains stablecoins, meme cash, LP tokens, and the whole lot in between. So, for those who’re trying to combine ERC20s into your dapps, then the Token API is the software for you!
With the Token API, you possibly can seamlessly combine balances, costs, transfers, and far more into your dapps with out breaking a sweat. What’s extra, with our ERC20 Owners endpoint, you may get sorted holders of a token with a single line of code.
The ERC20 Owners endpoint simplifies the method of fetching correct ERC20 proprietor knowledge right into a easy operation you possibly can full in a heartbeat. With this revolutionary 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 Owners endpoint:
import fetch from 'node-fetch';
const choices = {
methodology: 'GET',
headers: {
settle for: 'utility/json',
'X-API-Key': 'YOUR_API_KEY'
},
};
fetch(
"
choices
)
.then((response) => response.json())
.then((response) => console.log(response))
.catch((err) => console.error(err));
All you’ve gotten 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 house owners, together with their complete steadiness, the worth of their holdings, and far more. Right here’s an instance of what the response can seem like:
{
"cursor": "eyJhbGciOiJIUz//...",
"page": 1,
"page_size": 100,
"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
},
//...
]
}
The Advantages of Moralis’ ERC20 Owners Endpoint
Now that you’ve familiarized your self with the ERC20 Owners endpoint, let’s dive a bit deeper into the advantages of this characteristic:
- Fewer API Calls: Prior 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 knowledge right into a ready-to-use endpoint, you now want far fewer API calls to get the info you want.
- Token Holder Perception: With the ERC20 Owners 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 Owners endpoint, now you can effortlessly full complicated analytics duties. This contains figuring out distinctive holders, possession percentages, early adopters, newcomers, and so forth.
3-Step Tutorial: How to Get All Owners of an ERC20 Token with Moralis
We’ll now stroll you thru a easy tutorial on how to get sorted holders of a token utilizing Moralis’ Token API. And thanks to the accessibility of this industry-leading software, you’ll have the ability to get the info you want in three simple steps:
- Get a Moralis API Key
- Write a Script Calling the ERC20 Owners Endpoint
- Run the Code
Nonetheless, earlier than we will get going, you need to take care of some conditions!
Stipulations
This might 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, you want to create an account by clicking on the ”Begin for Free” button on the high proper on the Moralis homepage:
When you’re finished establishing your account, you want to log in, navigate to the ”Settings” tab, scroll down, and replica your key:
Maintain the important thing for now. You’re going to want it within the following step to initialize Moralis.
Step 2: Write a Script Calling the ERC20 Owners Endpoint
Begin by opening your most well-liked 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 set up 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:
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: 'utility/json',
'X-API-Key': 'YOUR_API_KEY'
},
};
fetch(
"
choices
)
.then((response) => response.json())
.then((response) => console.log(response))
.catch((err) => console.error(err));
From right here, you want to configure the code barely. First, exchange YOUR_API_KEY with the Moralis key you copied throughout step one. Subsequent, you additionally want to 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 operating the command under within the root folder of the mission:
node index.js
In return, you’ll get a response containing all house owners of the ERC20 token specified within the handle parameter. Right here’s an instance of what it would seem like:
{
"cursor": "eyJhbGciOiJIUz//...",
"page": 1,
"page_size": 100,
"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
},
//...
]
}
And that’s it; it doesn’t have to be tougher than that to get sorted holders of a token when working with Moralis!
Use Circumstances for Our API and the ERC20 Owners Endpoint
Our ERC20 Owners endpoint is indispensable for many builders constructing dapps associated to fungible tokens. Nonetheless, to provide you with a couple of examples, let’s discover three outstanding use circumstances for this characteristic:
- Token Analytics: Token analytics platforms are web sites or purposes that give customers worthwhile perception into the efficiency of the market and particular person tokens. An awesome instance of a mission leveraging our APIs is Moralis Money – the {industry}’s main token analytics platform.
- Portfolio Trackers: Portfolio trackers are platforms that give customers an entire overview of all their digital holdings. This sometimes contains each ERC20s and NFTs, in addition to shares and different digital belongings. Delta is an glorious instance of a portfolio tracker platform leveraging our APIs to hold customers up to date about current on-chain occasions.
- Cryptocurrency Wallets: Cryptocurrency wallets are web sites and purposes for storing digital belongings. The perfect wallets additionally present options for purchasing, 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 potential with Moralis. As such, let’s now discover some further APIs you’ll probably discover useful when constructing your dapps. Nonetheless, we received’t have the ability to cowl all of them on this information, which is why we’ll deal with the next three interfaces:
- Pockets API
- NFT API
- Blockchain API
When you’d like 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 knowledge, boasting an spectacular array of options, unparalleled scalability, and distinctive flexibility. It’s the right software for those who’re trying to construct your personal crypto pockets or combine pockets functionalities into your dapp!
With the Pockets API, you possibly can seamlessly fetch a pockets’s ERC20 balances, internet price, transaction historical past, and far more with a single line of code. To indicate you the way it works, we’ll now take a look at an instance of how simple 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",
"address": "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,
"page": 0,
"page_size": 100,
"result": [
{
"token_address": "0xae7ab96520de3a18e5e111b5eaab095312d7fe84",
"symbol": "stETH",
"name": "Liquid staked Ether 2.0",
"logo": "
"thumbnail": "
"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 software, try our official Pockets API web page!
NFT API
Moralis’ NFT API is Web3’s premier interface for NFT knowledge. This main software helps over three million NFT collections throughout all the most important chains, together with the whole lot 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 far more with single endpoints. As such, you possibly can construct the whole lot from marketplaces to Web3 video games with out breaking a sweat when utilizing the NFT API.
To focus on the accessibility of the NFT API, we’ll now present you ways 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",
"address": "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:
{
"status": "SYNCED",
"page": 1,
"page_size": 100,
"cursor": "eyJhbGciOiJIUzI1Ni//...",
"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": "
"minter_address": "0x13f11fd2c7c7be94674651386370d02b7aac9653",
"verified_collection": false,
"possible_spam": true,
"collection_logo": "",
"collection_banner_image": ""
},
//...
]
}
Please try our NFT API web page to study extra about this interface!
Blockchain API
The Blockchain API permits you to unlock the facility of uncooked blockchain knowledge with tempo and precision. It’s scalable, exact, and cross-chain, providing you with what you want to construct the whole lot from block explorers to analytics instruments!
With the Blockchain API, you possibly can seamlessly fetch block knowledge, transactions, sensible contract logs, and extra with single traces of code. To indicate 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",
"number": "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",
"difficulty": "0",
"total_difficulty": "58750003716598352816469",
"size": "7792",
"extra_data": "0x6265617665726275696c642e6f7267",
"gas_limit": "30000000",
"gas_used": "1372772",
"transaction_count": "11",
"base_fee_per_gas": "35229184857",
"transactions": [
//...
]
}
Try our Blockchain API web page to study extra about this premier interface!
Abstract: How to Get All Owners of an ERC20 Token
From a standard perspective, fetching the house owners 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 potential to circumvent this completely with Moralis’ ERC20 Owners endpoint!
With our ERC20 Owners endpoint, now you can get sorted holders of a token with a single API name. As well as to the house owners, you additionally get possession percentages, the USD worth of particular person holdings, and far more throughout the similar response. And with this premier characteristic, we’re lowering the limitations to complicated knowledge analytics, making token possession knowledge extra accessible to everybody!
When you appreciated this tutorial on how to get all house owners of an ERC20 token, contemplate studying extra content material right here at Moralis. As an illustration, try our most up-to-date article on the perfect crypto emblem API or learn the way to get the online price of any ERC20 pockets.
Additionally, don’t neglect you could enroll with Moralis free of cost. So, take this chance to supercharge your Web3 initiatives with streamlined knowledge integration from Moralis!
