Moralis Web3 offers an Enterprise-Grade API for Blockchain Address Labeling and Owner Identification

Do you need an easy way to identify blockchain address owners? If so, you’ll want to check out Moralis’ Blockchain Address Labeling API. This API enriches all our transaction and transfer endpoints with address and entity labels, giving you fully decoded data straight out of the box. Eager to learn how it works? Check out the entity-enriched sample response below: 

{
“hash”: “0x70c30285a9a4cc1c147cc94e5d0cefebe693fffd5fd5cbf727e2f86b6829d71b”,
“nonce”: “6810858”,
“transaction_index”: “72”,
“from_address”: “Oxa9d1e08c7793af67e9d92fe308d5697fb81d3e43”,
“from_address_label”: “Coinbase: Hot Wallet”,
“from_address_entity”: “Coinbase”,
“from_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/coinbase.png”,
“to_address”: “Oxa9d1e08c7793af67e9d92fe308d5697fb81d3e43”,
“to_address_label”: “Blackrock Wallet”,
“to_address_entity”: “Blackrock, Inc”,
“to_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/blackrock.png”,
“value”: “0”,
“gas”: “207128”,
“gas_price”: “32393720336”,
“input”: “0xa9059cbb000000000000000000000000c476723407b737c173bdfd87c7abc80f6856e6320000000000000000000000000000000000000000000000008533e3870aec3000”,
“receipt_cumulative_gas_used”: “8535588”,
“receipt_gas_used”: “52089”,
“receipt_contract_address”: null,
“receipt_root”: null,
“receipt_status”: “1”,
“block_timestamp”: “2023-06-26T16:48:23.000Z”,
“block_number”: “17564884”,
“block_hash”: “0x4e61fbb792a84c419a22ffcc590cbcb2f5a1b88d8e864d608e3544a3594c0e69”,
“transfer_index”: [17564884, 72]
}

As you can see, our API responses feature address and entity labels, logos, and much more, allowing you to automatically identify blockchain address owners when querying transaction data. To learn more about how this works, join us in this guide as we lay it all out. 

Want to start using our powerful APIs yourself? Sign up for a free Moralis account immediately and start leveraging the industry’s leading development tools today! 

Overview

Blockchain addresses aren’t inherently user-friendly, consisting of long, complex alphanumeric strings. Without proper labeling, users risk sending assets to incorrect addresses, struggle to identify address owners, and face increased chances of human error during blockchain interactions. Therefore, labels are crucial for the overall user experience in Web3. However, we understand the challenges of identifying blockchain address owners, which is why we introduced Moralis’ Blockchain Address Labeling API.

Our API enriches all transaction and transfer endpoints with labels for known addresses and entities, making it easier for developers and users to fully understand on-chain activity. But how does this work? And how can you leverage Moralis to identify blockchain address owners? If you’re looking for answers to these questions, join us in this tutorial. Let’s dive in!

Introducing Moralis’ Blockchain Address Labeling API – The Easiest Way to Identify Blockchain Address Owners

The Moralis Blockchain Address Labeling API automatically turns raw transaction input into decoded, human-readable data by enriching on-chain events with comprehensive address and entity labels representing companies, organizations, and known individuals. Some prominent examples include OpenSea, Uniswap, BlackRock, and Elon Musk. This makes it easier than ever before to identify blockchain address owners when querying transaction data.

Here’s an example of an entity-enriched response, highlighting the benefits of this feature:

{
“hash”: “0x70c30285a9a4cc1c147cc94e5d0cefebe693fffd5fd5cbf727e2f86b6829d71b”,
“nonce”: “6810858”,
“transaction_index”: “72”,
“from_address”: “Oxa9d1e08c7793af67e9d92fe308d5697fb81d3e43”,
“from_address_label”: “Coinbase: Hot Wallet”,
“from_address_entity”: “Coinbase”,
“from_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/coinbase.png”,
“to_address”: “Oxa9d1e08c7793af67e9d92fe308d5697fb81d3e43”,
“to_address_label”: “Blackrock Wallet”,
“to_address_entity”: “Blackrock, Inc”,
“to_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/blackrock.png”,
“value”: “0”,
“gas”: “207128”,
“gas_price”: “32393720336”,
“input”: “0xa9059cbb000000000000000000000000c476723407b737c173bdfd87c7abc80f6856e6320000000000000000000000000000000000000000000000008533e3870aec3000”,
“receipt_cumulative_gas_used”: “8535588”,
“receipt_gas_used”: “52089”,
“receipt_contract_address”: null,
“receipt_root”: null,
“receipt_status”: “1”,
“block_timestamp”: “2023-06-26T16:48:23.000Z”,
“block_number”: “17564884”,
“block_hash”: “0x4e61fbb792a84c419a22ffcc590cbcb2f5a1b88d8e864d608e3544a3594c0e69”,
“transfer_index”: [17564884, 72]
}

As shown, the output includes address labels, entity names, and logos for both the to_address and from_address, simplifying the process of decoding and understanding each transaction.

All in all, when querying transaction data using Moralis’ APIs, you’ll autonomously get address and entity labels, making it easy to identify blockchain address owners and understand exactly what’s happening on-chain! 

How Many Entities Does the Blockchain Address Labeling API Support?

Our Blockchain Address Labeling API currently supports over 500 entities and about 6,000 address labels, with the highest coverage across chains such as Ethereum, BNB Smart Chain (BSC), Polygon, Base, Optimism, and Arbitrum. Here are some of the supported categories: 

NFT Marketplaces

Influencers

DEXs

CEXs

Gaming

Meme

DeFi

Lending

L2s

DAOs

…and many more!

What Endpoints Are Covered?

All of our transfer and transaction endpoints feature address and entity labels. Here are five key examples: 

getWalletHistory()

getWalletTransactions()

getTransactions()

getWalletNFTTransfers()

…and many more! 

When calling any of these Moralis endpoints, you’ll be able to identify blockchain address owners without breaking a sweat! 

Why Do You Need Address & Entity Labels?

Without address labels, it’s challenging to fully understand on-chain transactions and transfers. While you might be aware of what’s being traded, you can’t easily tell who is interacting with whom. Fortunately, labels for known addresses partly solve this problem, giving you decoded data out of the box.

However, while address labels are a good start, this approach lacks depth, as users can’t access detailed information about the entities behind the addresses. This is why we also introduced entity labels to give developers and users a broader perspective, helping them identify blockchain address owners more seamlessly.

Blockchain Address Labeling API Benefits

Moralis’ Blockchain Address Labeling API offers many benefits. Below are three prominent examples:

In-depth Insight: Each entity is enriched with metadata, including logos, names, and more, providing a deeper understanding of blockchain transactions.

Advanced Querying: Seamlessly discover and search for entities and their associated addresses, unlocking innovative ways to analyze and interact with crypto data.

Contextualized Data: By linking multiple addresses to an entity, our API provides a complete overview of how entities operate across various blockchain networks.

Now that we’ve given you an overview of our Blockchain Address Labeling API, let’s show you how it works in practice!

Full Tutorial: How to Identify Blockchain Address Owners in 3 Steps

To demonstrate how to identify blockchain address owners, we’ll now show you our address and entity labels in action. To do so, we’ll walk you through a tutorial on how to get the native transactions of a wallet in three straightforward steps: 

Get a Moralis API Key

Write a Script

Run the Code

But before we can begin, you need to take care of a few prerequisites. 

Prerequisites

Before you proceed to the first step, make sure you have the following ready: 

Step 1: Get a Moralis API Key 

Sign up for an account with Moralis by clicking the ”Start for Free” button at the top right: 

Once you log in, you’ll find your API key under the ”Home” tab: 

Copy and keep it for now, as you’ll need it in the next step. 

Step 2: Write a Script

Set up a new folder in your preferred IDE and initialize a project with this terminal command:

npm init

Install the required dependencies using the terminal command below:

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

Add “type”: “module” to your ”package.json” file:

Create an ”index.js” file and add the following code:

import fetch from ‘node-fetch’;

const options = {
method: ‘GET’,
headers: {
accept: ‘application/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(‘https://deep-index.developers.moralis.com/api/v2.2/0x1f9090aaE28b8a3dCeaDf281B0F12828e676c326?chain=eth’, options)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

Replace YOUR_API_KEY with the key you fetched in the first step, and adjust the address parameter to fit your query:

Step 3: Run the Code

Open a new terminal and run this command in your project’s root folder to execute the script: 

node index.js

In return, you’ll get an array of the wallet’s past transactions. Here’s a sample response: 

{
//…
“result”: [
{
“hash”: “0x32fbeacaefcd2c3aac4d6b3785bbd3c3a1abf7059ccd2ab0b5ce882fe8b1a8a7”,
“nonce”: “689239”,
“transaction_index”: “236”,
“from_address_entity”: “rsync-builder”,
“from_address_entity_logo”: null,
“from_address”: “0x1f9090aae28b8a3dceadf281b0f12828e676c326”,
“from_address_label”: “rsync-builder: rsync-builder.eth”,
“to_address_entity”: “Lido”,
“to_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/lido.png”,
“to_address”: “0x388c818ca8b9251b393131c08a736a67ccb19297”,
“to_address_label”: “Lido: Execution Layer Rewards Vault”,
“value”: “145625272627297007”,
“gas”: “22111”,
“gas_price”: “6666132382”,
“input”: “0x”,
“receipt_cumulative_gas_used”: “22570408”,
“receipt_gas_used”: “22111”,
“receipt_contract_address”: null,
“receipt_root”: null,
“receipt_status”: “1”,
“block_timestamp”: “2024-08-21T15:22:35.000Z”,
“block_number”: “20577863”,
“block_hash”: “0x4a3128adc3d3ee7bdfe7872d2235cf1089905135efd9dc179b57f1dd6239e304”,
“transfer_index”: [
20577863,
236
],
“transaction_fee”: “0.000147394853098402”
},
//…
]
}

As you can see, the response is fully enriched with a lot of useful metadata, including address and entity labels, logos, and more:

“from_address_entity”: “rsync-builder”,
“from_address_entity_logo”: null,
“from_address”: “0x1f9090aae28b8a3dceadf281b0f12828e676c326”,
“from_address_label”: “rsync-builder: rsync-builder.eth”,
“to_address_entity”: “Lido”,
“to_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/lido.png”,
“to_address”: “0x388c818ca8b9251b393131c08a736a67ccb19297”,
“to_address_label”: “Lido: Execution Layer Rewards Vault”,

That’s how easy it is to identify blockchain address owners when working with Moralis’ Web3 API suite! 

To learn more about this, check out the official entities and labeling documentation page. 

Blockchain Address Labeling API Use Cases

Labels for known addresses and entities have several critical applications. Here are three key examples:

Portfolio Trackers: Entity labels can streamline portfolio tracking, allowing users to easily follow the activity of whales and other entities with multiple addresses. In essence, these labels can help give a complete overview of the actions of organizations and known individuals. 

Analytics Platforms: Entity labels simplify the analysis of on-chain activity, enabling bulk queries of transaction data for known organizations or individuals. This makes it easier to gain insights into and analyze on-chain behavior.

Web3 Wallets: Labels for addresses and entities can enhance the experience of a Web3 wallet, giving users better insight into what protocols, addresses, and individuals they’re interacting with. 

These are just a few prominent examples, and our Blockchain Address Labeling API can be helpful when building most dapps!  

Beyond Our Blockchain Address Labeling API – Exploring Moralis Further

Moralis is your go-to Web3 data provider, giving you seamless access to next-generation nodes and top-tier APIs, including the Wallet API, Token API, Streams API, and many more. As such, when leveraging Moralis, you get all crypto data in one single place. 

But what makes our development tools unique? 

Comprehensive: Our APIs and Extended RPC Methods are designed to be outcome-oriented, giving you more data with fewer API calls. Fetch any wallet’s full history, token balances with prices, NFT balances, and much more with single requests, minimizing the effort needed to build dapps. 

Multi-Chain: Moralis supports multiple chains, including Ethereum, Polygon, BSC, Optimism, Base, and many more. And with our development tools, you get to experience full feature parity across all these blockchain networks.  

Secure: Moralis is SOC 2 Type 2 certified, showcasing our commitment to maintaining high security and reliability across both our APIs and RPC nodes. 

Nevertheless, to further understand the benefits of Moralis, let’s dive deeper into our suite of Web3 development tools! 

Web3 APIs

The Moralis suite of Web3 APIs comprises several use case-specific interfaces. Here are seven key examples: 

Wallet API: Get a wallet’s full history, token balances, NFT balances, net worth, profitability, and much more with single lines of code. This is a great interface for anyone looking to integrate wallet functionality into their dapps. 

NFT API: Access NFT balances, up-to-date metadata, prices, transactions, and much more with single requests. Use this API to streamline the development of NFT marketplaces, Web3 games, and other similar platforms. 

Token API: Fetch token balances, metadata, prices, transactions, and more. This is the ultimate ERC-20 data solution, helping you create everything from portfolio trackers to DEXs without breaking a sweat. 

Price API: Get real-time and historical prices for NFTs and ERC-20 tokens alike. The Price API is the ultimate solution if you’re looking to integrate token data into your dapps. 

Streams API: The Streams API is Web3’s most prominent real-time data solution, allowing you to configure customized streams at the click of a few buttons. Set up real-time alerts, stream data into your databases, and populate your dapps with the most recent on-chain events. 

Discovery API: This is the ultimate API for discovering hidden gems. With single requests, you can effortlessly query rising liquidity tokens, experienced buyer tokens, trending tokens, and more. 

Market Data API: Get in-depth insight into the market with only single lines of code. Seamlessly query top tokens by market cap, top tokens by price change, top NFTs by trading volume, and much more. 

Check out the Web3 API page to learn more about all our premier interfaces! 

RPC Nodes

With Moralis, you can effortlessly set up nodes for all major chains, including Ethereum, Polygon, BSC, Optimism, and Base. So, no matter what chain you’re building on, we’ve got you covered! 

But why should you leverage our RPC nodes? 

Speed: Our nodes feature response times from 70 ms, setting the industry benchmark for speed. 

Reliability: With 99.9% uptime, you can safely rely on our node infrastructure. 

Extended RPC Methods: Query decoded, human-readable data with our Extended RPC Methods, including wallet balances, token prices, metadata, and more. 

Visit our RPC nodes page to learn more about our next-generation nodes! 

Summary: Blockchain Address Labeling API – Identify Blockchain Address Owners

Blockchain addresses are long strings of letters and numbers, designed to be read by computers.. Without proper labeling, it’s hard for us to distinguish between crypto addresses, leading to a poor Web3 user experience. And we know how hard it is to identify blockchain address owners, which is why we built our Blockchain Address Labeling API.

The Blockchain Address Labeling API is responsible for enriching all our transfer and transaction endpoints with labels for known addresses and entities. Some prominent examples include OpenSea, Uniswap, BlackRock, and Elon Musk. This makes it easy for developers and end users to identify blockchain address owners when querying transfer data using our APIs. 

The Blockchain Address Labeling API currently supports 500+ entities and about 6,000 address labels, with the most significant coverage spanning across chains like Ethereum, BSC, Optimism, Base, Arbitrum, and Polygon. So, no matter what chain you’re building on, we got you covered. 

To show you how it works, here’s an entity-enriched sample response:

{
“hash”: “0x70c30285a9a4cc1c147cc94e5d0cefebe693fffd5fd5cbf727e2f86b6829d71b”,
“nonce”: “6810858”,
“transaction_index”: “72”,
“from_address”: “Oxa9d1e08c7793af67e9d92fe308d5697fb81d3e43”,
“from_address_label”: “Coinbase: Hot Wallet”,
“from_address_entity”: “Coinbase”,
“from_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/coinbase.png”,
“to_address”: “Oxa9d1e08c7793af67e9d92fe308d5697fb81d3e43”,
“to_address_label”: “Blackrock Wallet”,
“to_address_entity”: “Blackrock, Inc”,
“to_address_entity_logo”: “https://entities-logos.s3.us-east-1.amazonaws.com/blackrock.png”,
“value”: “0”,
“gas”: “207128”,
“gas_price”: “32393720336”,
“input”: “0xa9059cbb000000000000000000000000c476723407b737c173bdfd87c7abc80f6856e6320000000000000000000000000000000000000000000000008533e3870aec3000”,
“receipt_cumulative_gas_used”: “8535588”,
“receipt_gas_used”: “52089”,
“receipt_contract_address”: null,
“receipt_root”: null,
“receipt_status”: “1”,
“block_timestamp”: “2023-06-26T16:48:23.000Z”,
“block_number”: “17564884”,
“block_hash”: “0x4e61fbb792a84c419a22ffcc590cbcb2f5a1b88d8e864d608e3544a3594c0e69”,
“transfer_index”: [17564884, 72]
}

As you can see, when querying data using Moralis, you get entity names, logos, and much more, giving you fully decoded data straight out of the box. And with this data, you can now improve the user experience of your projects! 

If you liked this Blockchain Address Labeling API article, consider reading some more Moralis content. For instance, check out our tutorial on how to get wallet transactions using RPC nodes or read about the best QuickNode Streams alternative. 

Also, if you wish to leverage our APIs yourself, remember to sign up with Moralis. You can create an account free of charge, and you’ll gain immediate access to all our industry-leading development tools!