ERC20 Token Balance – Get the Balance of ERC20 Tokens

At this time’s tutorial demonstrates easy methods to get the ERC20 token stability of an tackle with the Moralis Token API. Due to the accessibility of this device, all you want is a single API name to the getWalletTokenBalances() endpoint. Right here’s an instance of what it may seem like: 

const Moralis = require(“moralis”).default;
const { EvmChain } = require(“@moralisweb3/common-evm-utils”);

const runApp = async () => {
await Moralis.begin({
apiKey: “YOUR_API_KEY”,
// …and another configuration
});

const tackle = “0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d”;

const chain = EvmChain.ETHEREUM;

const response = await Moralis.EvmApi.token.getWalletTokenBalances({
tackle,
chain,
});

console.log(response.toJSON());
};

runApp();

All it’s important to do is exchange YOUR_API_KEY together with your Moralis API key, configure the tackle and chain parameters to suit your request, and run the code. In return, you’ll get an array of tokens containing the stability for every: 

[
{
“token_address”: “0x3c978fc9a42c80a127863d786d8883614b01b3cd”,
“symbol”: “USDT”,
“name”: “USDTOKEN”,
“logo”: null,
“thumbnail”: null,
“decimals”: 18,
“balance”: “10000000000000000000000”,
“possible_spam”: true
},
{
“token_address”: “0xdac17f958d2ee523a2206206994597c13d831ec7”,
“symbol”: “USDT”,
“name”: “Tether USD”,
“logo”: “https://cdn.moralis.io/eth/0xdac17f958d2ee523a2206206994597c13d831ec7.png”,
“thumbnail”: “https://cdn.moralis.io/eth/0xdac17f958d2ee523a2206206994597c13d831ec7_thumb.png”,
“decimals”: 6,
“balance”: “102847”,
“possible_spam”: false
},
//…
]

That’s it; when working with Moralis, it’s straightforward to get the ERC20 token stability of an tackle. From right here, now you can use this information and effortlessly combine it into your Web3 tasks! 

For those who’d prefer to study extra about how this works, be part of us on this article or try the official documentation on easy methods to get ERC20 token stability by a pockets.

Additionally, keep in mind to enroll with Moralis, as you’ll want an account to observe alongside on this tutorial. You possibly can register totally without cost, and also you’ll achieve quick entry to the trade’s main Web3 APIs! 

Overview

A vital facet of most blockchain functions – together with wallets, decentralized exchanges (DEXs), portfolio trackers, and Web3 analytics instruments – are ERC20 token balances. Consequently, it doesn’t matter what decentralized software (dapp) you’re constructing, you’ll probably want the flexibility to effortlessly get the ERC20 token stability of an tackle. Nevertheless, querying and processing this information with out correct improvement instruments is a tedious and time-consuming job. Happily, now you can keep away from the difficult elements by leveraging the Moralis Token API to get the ERC20 token stability of an tackle very quickly! 

In at present’s article, we’ll begin by going again to fundamentals and briefly study what a token stability is. From there, we’re additionally going to discover ERC20, as that is the most well-liked commonplace for fungible tokens. Subsequent, we’ll leap straight into the tutorial and present you easy methods to seamlessly get the ERC20 token stability of an tackle utilizing the Moralis Token API. To high issues off, we’ll additionally present you easy methods to use the Token API to get the spender allowance of an ERC20 token! 

For those who already know what a token stability is and what the ERC20 token commonplace entails, be happy to skip straight into the ”Tutorial: The way to Get the ERC20 Token Steadiness of an Tackle” part! 

Additionally, in the event you’re severe about constructing Web3 tasks, you’ll probably need to try another instruments Moralis provides apart from the Token API. As an illustration, two different wonderful interfaces are Moralis’ free NFT API and the free crypto Value API. With these instruments, you may seamlessly construct Web3 tasks in a heartbeat! 

So, if you need entry to the trade’s main Web3 APIs, keep in mind to enroll with Moralis so you can begin leveraging the true energy of blockchain expertise at present!

What’s a Token Steadiness? 

A token stability refers back to the quantity of a specific cryptocurrency an account or pockets holds. Within the crypto world, there are two main fungible token sorts: native and non-native tokens. Let’s have a look at every slightly bit deeper:

Native Tokens: A local token is a blockchain community’s base cryptocurrency. All impartial blockchains have their very own native token. They usually have loads of utility inside their respective ecosystems. As an illustration, a local token is usually used to reward validators/miners and pay for transaction charges. A outstanding instance is ETH, which is the native token of the Ethereum community.  Non-Native Tokens: Non-native tokens are created on high of an current community – corresponding to Ethereum – utilizing sensible contracts. These tokens are sometimes created by a Web3 mission and are solely used inside its personal borders. Examples of non-native tokens embrace DAI, USDT, and USDC. 

So, when speaking a few token stability, we sometimes consult with the quantity of a specific native or non-native token an account or pockets holds. Furthermore, though there are numerous forms of fungible tokens, they principally observe the ERC20 token commonplace. However what precisely does this imply? And the way does ERC20 work? 

What’s ERC20? 

ERC20, or Ethereum Request for Remark 20, is a technical commonplace for sensible contracts on the Ethereum blockchain and different EVM-compatible networks. This commonplace defines a algorithm, capabilities, and occasions {that a} token should implement for it to be thought-about ERC-20 compliant. 

The capabilities and occasions outlined within the ERC20 token commonplace present a standard interface for all tokens to allow them to be simply accessed, acknowledged, and used. As an illustration, one of many capabilities is balanceOf(), making certain that it’s attainable to seamlessly get a consumer’s stability of any ERC20 token. 

Nonetheless, this commonplace interface ensures a unified ecosystem the place all tokens are suitable with each other, together with decentralized functions (dapps) and different Web3 tasks. Some outstanding examples of ERC20 tokens embrace ETH, USDC, USDT, SHIB, and plenty of others! 

Additionally, whereas ERC20 is the most well-liked and well-used token commonplace, it’s removed from the one one. Two further requirements are ERC721 and ERC1155, that are used to manage NFTs on the Ethereum blockchain. For those who’d prefer to study extra about these, try our article on ERC721 vs. ERC1155! 

Nonetheless, now that you’ve got a greater understanding of what ERC20 entails, let’s leap straight into the tutorial and present you easy methods to get a pockets’s ERC20 token stability! 

Tutorial: The way to Get the ERC20 Token Steadiness of an Tackle

One of the best and most easy option to get the ERC20 token stability of a consumer is to leverage the Moralis Token API. This API supplies real-time ERC20 token information, permitting you to fetch costs, transfers, and, in fact, balances with a single line of code! 

The API can be cross-chain suitable, supporting ten-plus EVM chains, together with Ethereum, BNB Sensible Chain, Polygon, and plenty of others. As such, with Moralis, it has by no means been simpler to construct crypto wallets, portfolio trackers, or Web3 token analytics instruments!

Nonetheless, to spotlight the accessibility of this device, we’ll take the next sections to point out you easy methods to get the ERC20 token stability of a consumer in three easy steps: 

Get an API KeyWrite a ScriptRun the Code

However earlier than we leap into step one of the tutorial, you’ll need to deal with a number of conditions! 

Conditions  

On this tutorial, we’ll present easy methods to get the ERC20 token stability of a consumer with JavaScript. Nevertheless, you too can use TypeScript and Python in the event you desire. However if so, be aware that the steps outlined on this tutorial may differ barely. 

Nonetheless, earlier than you get going, you’ll have to have the next prepared: 

From right here, you might want to set up the Moralis SDK. To take action, arrange a brand new mission in your built-in improvement surroundings (IDE) and run the next terminal command in your mission’s root folder: 

npm set up moralis @moralisweb3/common-evm-utils

That’s it; you’re now prepared to leap into step one of this tutorial on easy methods to get the ERC20 token stability of a consumer! 

Step 1: Get an API Key 

You’ll initially want a Moralis API key, which is required for making calls to the Token API. Happily, you may get your API key without cost. All it’s important to do is join with Moralis by clicking on the ”Begin for Free” button on the high proper of the Moralis homepage: 

When you’re performed establishing an account and your first mission, you will discover the important thing by navigating to the ”Settings” tab. From there, you may merely scroll down and replica your Moralis API key: 

Save the important thing, as you’ll want it within the subsequent step! 

Step 2: Write a Script 

With a Moralis API key at hand, you’re prepared to begin coding. As such, arrange a brand new ”index.js” file in your mission’s root folder and add the next code: 

const Moralis = require(“moralis”).default;
const { EvmChain } = require(“@moralisweb3/common-evm-utils”);

const runApp = async () => {
await Moralis.begin({
apiKey: “YOUR_API_KEY”,
// …and another configuration
});

const tackle = “0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d”;

const chain = EvmChain.ETHEREUM;

const response = await Moralis.EvmApi.token.getWalletTokenBalances({
tackle,
chain,
});

console.log(response.toJSON());
};

runApp();

That is all of the code you might want to get the ERC20 token stability of a consumer. Nevertheless, you might want to make a number of minor configurations earlier than you may run the script. 

To start with, exchange YOUR_API_KEY with the important thing you copied within the earlier step: 

Subsequent, you might want to configure the tackle and chain parameters to suit your request. For the tackle const, add the pockets tackle from which you need to get the ERC20 token stability. And for chain, you may swap the community in the event you want to question a blockchain aside from Ethereum: 

From there, we then go the parameters when calling the getWalletTokenBalances() endpoint:

That is it; that’s all of the code you might want to get the ERC20 token stability of a consumer. All that continues to be from right here is operating the script! 

Step 3: Run the Code 

To run the script, merely open a terminal, cd into the mission’s root folder, and execute the next command: 

node index.js

In return, you’ll get a response containing an array of ERC20 tokens together with the stability for every cryptocurrency. Right here’s an instance of what it’d seem like: 

[
{
“token_address”: “0x3c978fc9a42c80a127863d786d8883614b01b3cd”,
“symbol”: “USDT”,
“name”: “USDTOKEN”,
“logo”: null,
“thumbnail”: null,
“decimals”: 18,
“balance”: “10000000000000000000000”,
“possible_spam”: true
},
{
“token_address”: “0xdac17f958d2ee523a2206206994597c13d831ec7”,
“symbol”: “USDT”,
“name”: “Tether USD”,
“logo”: “https://cdn.moralis.io/eth/0xdac17f958d2ee523a2206206994597c13d831ec7.png”,
“thumbnail”: “https://cdn.moralis.io/eth/0xdac17f958d2ee523a2206206994597c13d831ec7_thumb.png”,
“decimals”: 6,
“balance”: “102847”,
“possible_spam”: false
},
//…
]

From right here, now you can effortlessly combine the ERC20 token stability information into your tasks!

The way to Get Spender Allowance of an ERC20 Token 

Along with getting the ERC20 token stability of a consumer, the Moralis Token API additionally lets you question the spender allowance of an ERC20 token. However what precisely is the spender allowance? 

ERC20 token allowance refers back to the quantity {that a} spender is allowed to withdraw on behalf of the proprietor. That is frequent when interacting with dapps like Uniswap, giving the platform the appropriate to switch the tokens you maintain in your pockets. 

So, how will you get the spender allowance of an ERC20 token? 

Properly, because of the accessibility of the Moralis Token API, you may observe the identical steps from the ”Tutorial: The way to Get the ERC20 Token Steadiness…” part. The one distinction is that you might want to name the getTokenAllowance() endpoint as an alternative of getWalletTokenBalances(). 

As such, if you wish to get the spender allowance of an ERC20 token, merely exchange the contents in your ”index.js” file with the next code: 

const Moralis = require(“moralis”).default;
const { EvmChain } = require(“@moralisweb3/common-evm-utils”);

const runApp = async () => {
await Moralis.begin({
apiKey: “YOUR_API_KEY”,
// …and another configuration
});

const chain = EvmChain.ETHEREUM;

const tackle = “0x514910771AF9Ca656af840dff83E8264EcF986CA”;

const ownerAddress = “0x7c470D1633711E4b77c8397EBd1dF4095A9e9E02”;

const spenderAddress = “0xed33259a056f4fb449ffb7b7e2ecb43a9b5685bf”;

const response = await Moralis.EvmApi.token.getTokenAllowance({
tackle,
chain,
ownerAddress,
spenderAddress,
});

console.log(response.toJSON());
};

runApp();

From right here, you’ll then want so as to add your API key by changing YOUR_API_KEY: 

Subsequent, you have to configure the parameters, and as you’ll rapidly discover, there are a number of extra this time. For the tackle parameter, you might want to add the token tackle. For ownerAddress, add the tackle of the token proprietor. And for spenderAddress, add the tackle of the token spender: 

We then go these parameters when calling the getTokenAllowance() endpoint:

When you run the code, you’ll get a response wanting one thing like this:

{
“allowance”: “0”
}

And that’s it! That is how straightforward it’s to get the spender allowance of an ERC20 token when working with Moralis! 

For a extra detailed breakdown of how this works, try the get spender allowance of an ERC20 token documentation! 

Abstract: The way to Get the Steadiness of ERC20 Tokens

In at present’s article, we launched you to ERC20 token balances. In doing so, we defined what they’re and how one can get the ERC20 token stability of a consumer with the Moralis Value API in three steps: 

Get an API KeyWrite a ScriptRun the Code

You probably have adopted alongside this far, you now know easy methods to get the ERC20 token stability of any tackle. Now you can use this newly acquired talent to begin constructing your first Web3 mission!

If that is your ambition, then you need to know that the Token API works like a dream along with our suite of further crypto APIs. You possibly can, for example, mix the Token API with the Moralis NFT API to combine NFT information into your tasks. For those who’d prefer to study extra about this, try our articles on easy methods to get NFT ERC721 on-chain metadata or easy methods to get all NFT tokens owned by a consumer tackle. 

Additionally, in the event you appreciated this tutorial, contemplate testing further content material right here on the Web3 weblog. For instance, dive into consideration abstraction, discover the trade’s main NFT picture API, or discover ways to write a wise contract in Solidity! 

Lastly, don’t overlook to enroll with Moralis if you wish to entry the trade’s main Web3 APIs. Creating an account is free, and as a consumer of Moralis, you’ll be capable of construct tasks quicker and smarter!