[ad_1]
Are you on the lookout for the best strategy to get all homeowners of an ERC20 token? If that’s the case, then you definitely’re precisely the place it is advisable to be! In at this time’s information, we’ll present you how you can get sorted holders of a token in a heartbeat utilizing Moralis’ Token API. If you happen to instantly need to bounce straight into the code, try our ERC20 House owners endpoint in motion down beneath:
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 extra knowledge, comparable to proprietor percentages, the USD worth of particular person holdings, and so on. Right here’s an instance of what it’d appear to be:
{
“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 would like a extra detailed breakdown, please try the documentation web page for our ERC20 House owners endpoint or be part of us on this information.
Additionally, should you want to get all homeowners of an ERC20 token your self, don’t overlook to enroll with Moralis. You may create an account totally free, and also you’ll achieve instantaneous entry to our premier suite of growth instruments!
Overview
Figuring out the homeowners of an ERC20 token has been fairly a bothersome process from a standard perspective. Usually, this course of requires manually monitoring possession adjustments and transactions throughout numerous protocols, making a workflow that’s each time-intensive and complicated. Certainly, there should be a extra environment friendly methodology, proper?
At Moralis, we got down to remodel this historically tough course of right into a easy process you may full with out breaking a sweat. And that is exactly what our ERC20 House owners endpoint permits you to do. So, should you’d wish to discover the best strategy to get sorted holders of a token, then this learn is for you. Let’s bounce straight into it by introducing Moralis!
What’s Moralis? – The Best Technique to Get All House owners of an ERC20 Token
Moralis is the {industry}’s main Web3 knowledge supplier, supplying the assets it is advisable to construct refined dapps. In our suite of growth instruments, you’ll discover every little thing from top-tier blockchain nodes to 10+ use case-specific APIs. What’s extra, Moralis at the moment 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 Knowledge: All our APIs are designed to reduce the requests it is advisable to construct dapps. This implies you get extra knowledge with fewer API calls when working with Moralis, resulting in decrease prices and enhanced effectivity. Streamline Your Improvement Expertise: Moralis’ APIs are intuitive and totally cross-chain. As such, you don’t must hassle with a number of suppliers for varied chains when utilizing our APIs, supplying 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.
However, that offers you an summary of Moralis. Let’s now dive a bit deeper into our Web3 API suite and discover the Token API – one of the best instrument to get all homeowners of an ERC20 token!
Moralis’ Token API and the ERC20 House owners Endpoint
Moralis’ Token API is the {industry}’s #1 instrument for ERC20 token knowledge, supporting each single token throughout all main chains. This contains stablecoins, meme cash, LP tokens, and every little thing in between. So, should you’re seeking to combine ERC20s into your dapps, then the Token API is the instrument for you!
With the Token API, you may seamlessly combine balances, costs, transfers, and way more into your dapps with out breaking a sweat. What’s extra, with our ERC20 House owners endpoint, you may get sorted holders of a token with a single line of code.
The ERC20 House owners endpoint simplifies the method of fetching correct ERC20 proprietor knowledge right into a easy operation you may full in a heartbeat. With this progressive function, now you can fetch the highest holders and whole provide of any token, together with possession percentages, the USD worth of particular person holdings, and extra, with ease.
So, how does it work?
Effectively, to reply the above query, let’s dive into a brief script calling our ERC20 House owners endpoint:
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));
All it’s important to do is change YOUR_API_KEY along 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 whole steadiness, the worth of their holdings, and way more. Right here’s an instance of what the response can appear to be:
{
“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
},
//…
]
}
The Advantages of Moralis’ ERC20 House owners Endpoint
Now that you’ve familiarized your self with the ERC20 House owners endpoint, let’s dive a bit deeper into the advantages of this function:
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 House owners endpoint, you may seamlessly fetch the highest holders of any token, considerably boosting transparency and the understanding of token distribution. Simplified Token Analytics: With the ERC20 House owners endpoint, now you can effortlessly full complicated analytics duties. This contains figuring out distinctive holders, possession percentages, early adopters, newcomers, and so on.
3-Step Tutorial: Learn how to Get All House owners of an ERC20 Token with Moralis
We’ll now stroll you thru a easy tutorial on how you can get sorted holders of a token utilizing Moralis’ Token API. And due to the accessibility of this industry-leading instrument, you’ll be capable of get the info you want in three simple steps:
Get a Moralis API KeyWrite a Script Calling the ERC20 House owners EndpointRun the Code
Nonetheless, earlier than we are able to get going, you could cope with some stipulations!
Conditions
This will likely be a JavaScript and Node.js tutorial. As such, should you haven’t already, be sure you arrange the next earlier than persevering with:
Step 1: Get a Moralis API Key
To get a Moralis API key, it is advisable 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, it is advisable to log in, navigate to the ”Settings” tab, scroll down, and duplicate your key:
Preserve 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 House owners Endpoint
Begin by opening your most well-liked IDE and arrange a folder. Subsequent, open a brand new terminal and initialize a undertaking with the command beneath:
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 ”kind”: ”module” to the record:
You may 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’
},
};
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));
From right here, it is advisable to configure the code barely. First, change YOUR_API_KEY with the Moralis key you copied throughout step one. Subsequent, you additionally have to configure question parameters to suit your question.
That’s it for the code. All that is still from right here is executing the script!
Step 3: Run the Code
You may execute the code by opening a brand new terminal and working the command beneath within the root folder of the undertaking:
node index.js
In return, you’ll get a response containing all homeowners of the ERC20 token specified within the tackle parameter. Right here’s an instance of what it’d appear to be:
{
“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
},
//…
]
}
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 House owners Endpoint
Our ERC20 House owners endpoint is indispensable for many builders constructing dapps associated to fungible tokens. Nonetheless, to provide you a number of examples, let’s discover three outstanding use instances for this function:
Token Analytics: Token analytics platforms are web sites or functions that give customers priceless perception into the efficiency of the market and particular person tokens. An ideal instance of a undertaking leveraging our APIs is Moralis Cash – 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 usually contains each ERC20s and NFTs, in addition to shares and different digital belongings. Delta is a superb instance of a portfolio tracker platform leveraging our APIs to maintain customers up to date about current on-chain occasions.
Cryptocurrency Wallets: Cryptocurrency wallets are web sites and functions for storing digital belongings. One of the best 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 extra APIs you’ll seemingly discover useful when constructing your dapps. Nonetheless, we received’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
If you happen to’d wish to discover all our APIs, please go to the official Web3 API web page, which features a record of all accessible interfaces!
Pockets API
The Pockets API is the {industry}’s #1 API for pockets knowledge, boasting a formidable array of options, unparalleled scalability, and distinctive flexibility. It’s the proper instrument should you’re seeking to construct your personal crypto pockets or combine pockets functionalities into your dapp!
With the Pockets API, you may seamlessly fetch a pockets’s ERC20 balances, web value, transaction historical past, and way more with a single line of code. To indicate you the way it works, we’ll now have 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’;
attempt {
await Moralis.begin({
apiKey: “YOUR_API_KEY”
});
const response = await Moralis.EvmApi.wallets.getWalletTokenBalancesPrice({
“chain”: “0x1”,
“tackle”: “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 illustration, 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 instrument, try our official Pockets API web page!
NFT API
Moralis’ NFT API is Web3’s premier interface for NFT knowledge. This main instrument helps over three million NFT collections throughout all the most important chains, together with every little thing from established initiatives like Nakamigos to tokens that dropped simply seconds in the past!
With the NFT API, you may seamlessly fetch metadata, balances, optimized picture previews, and way more with single endpoints. As such, you may construct every little thing 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 how you can fetch the steadiness of any pockets with our getWalletNFTs() endpoint:
import Moralis from ‘moralis’;
attempt {
await Moralis.begin({
apiKey: “YOUR_API_KEY”
});
const response = await Moralis.EvmApi.nft.getWalletNFTs({
“chain”: “0x1”,
“tackle”: “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 would possibly appear to be:
{
“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 enables you to unlock the facility of uncooked blockchain knowledge with tempo and precision. It’s scalable, exact, and cross-chain, supplying you with what it is advisable to construct every little thing from block explorers to analytics instruments!
With the Blockchain API, you may seamlessly fetch block knowledge, transactions, sensible contract logs, and extra with single strains of code. To indicate you the way it works, let’s have a look at our getBlock() endpoint, permitting you to fetch the contents of any given block:
import Moralis from ‘moralis’;
attempt {
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 tackle, gasoline restrict, and extra. Right here’s an instance of what the response will appear to be:
{
“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”,
“dimension”: “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 be taught extra about this premier interface!
Abstract: Learn how to Get All House owners of an ERC20 Token
From a standard perspective, fetching the homeowners of an ERC20 token has been an annoying process. It usually requires manually monitoring possession and transactions throughout the blockchain, which is each tedious and time-consuming. Thankfully, it’s now potential to avoid this completely with Moralis’ ERC20 House owners endpoint!
With our ERC20 House owners 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 identical response. And with this premier function, we’re lowering the boundaries to complicated knowledge analytics, making token possession knowledge extra accessible to everybody!
If you happen to appreciated this tutorial on how you can get all homeowners of an ERC20 token, take into account studying extra content material right here at Moralis. For example, try our most up-to-date article on one of the best crypto emblem API or discover ways to get the web 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 knowledge integration from Moralis!
[ad_2]
Source link