Are you in search of the very best and best strategy to construct decentralized functions (dapps) on Linea? You’ve come to the proper place. On this information, we’ll introduce you to Moralis – the {industry}’s main Web3 knowledge supplier. With Moralis’ top-tier instruments, you’ll be able to seamlessly combine on-chain knowledge into your Linea dapps with just some strains of code, making improvement quicker and extra environment friendly!
For a sneak peek, try our Pockets Historical past endpoint in motion:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(‘https://deep-index.moralis.io/api/v2.2/wallets/0x5856EDF9212bdceC74301ec78AFc573B62D6A283/historical past?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
In return for calling the endpoint above, you’ll get the total historical past of the required pockets. Moreover, the API response is enriched with automated class tags, summaries, tackle labels, and extra for every occasion, supplying you with decoded knowledge straight out of the field. Right here’s an instance of what it would appear like:
{
//…
“consequence”: [
{
//…
“native_transfers”: [
{
“from_address”: “0x53d3801bc009867485eb69e6178e1c0deca3fddc”,
“from_address_label”: null,
“to_address”: “0xde1e598b81620773454588b85d6b5d4eec32573e”,
“to_address_label”: null,
“value”: “9223865045570189”,
“value_formatted”: “0.009223865045570188”,
“direction”: “send”,
“internal_transaction”: false,
“token_symbol”: “ETH”,
“token_logo”: “https://cdn.moralis.io/eth/0x.png”
}
],
“abstract”: “Despatched 0.009224 ETH to 0xde…573e”,
“possible_spam”: false,
“class”: “ship”
},
//…
]
}
To study extra about Moralis and the way to seamlessly construct dapps on Linea, be part of us on this information as we dive deeper into the method!
Prepared to begin constructing your personal dapps on Linea? Enroll with Moralis in the present day! You possibly can create a free account and acquire speedy entry to our premier nodes and Web3 APIs!
Overview
Whether or not you’re constructing a cryptocurrency pockets, an NFT market, or some other dapps on Linea, seamless entry to on-chain knowledge is crucial. Nevertheless, querying blockchain knowledge has historically been a cumbersome and time-consuming course of. Doing so from scratch calls for a classy underlying infrastructure, in addition to handbook knowledge aggregation and decoding. This takes a variety of time that may be higher spent on constructing options and enhancing the person expertise of your dapps. As such, there must be a greater method, proper?
Thankfully, now you can streamline on-chain knowledge integration on your Linea dapps with Moralis – Web3’s premier infrastructure supplier. Moralis lets you question knowledge for wallets, NFTs, tokens, and far more with just some strains of code. When you’d prefer to study extra about this, be part of us on this information as we introduce you to the simplest strategy to construct dapps on Linea. Let’s dive straight in!
What’s Linea?
Linea, developed by ConsenSys and launched in 2023, is a completely EVM-equivalent layer-2 (L2) scaling resolution for Ethereum. Designed to boost flexibility and scalability for dapps, Linea affords a extremely engaging surroundings for each builders and finish customers!

The Linea blockchain, powered by modern zero-knowledge (ZK) roll-up know-how, affords larger throughput and decrease transaction charges in comparison with Ethereum. That is achieved by bundling a number of off-chain transactions into single ZK-proofs, that are submitted and verified on the Ethereum blockchain in bulk. In consequence, Linea gives lightning-fast transactions whereas sustaining the excessive safety of the Ethereum mainnet.
Regardless of being a comparatively new ecosystem, Linea boasts a considerable community with over a million month-to-month lively customers and greater than 300 dapps. Among the many outstanding names on the community are Stargate, SyncSwap, and Particle Community.
Now that you’ve an outline of Linea, let’s discover a number of the advantages of constructing dapps on this modern chain!
Why Construct Dapps on Linea?
Constructing dapps on Linea generally is a nice choice. To focus on why, we’ll now discover 5 advantages of the community:
EVM Equivalence: Linea is totally EVM equal, guaranteeing seamless compatibility with current Ethereum good contracts and dapps. This makes it simple for builders emigrate their tasks to Linea with out vital modifications to their codebases. Ease of Use: With its EVM equivalence, Linea helps many acquainted instruments, together with wallets like MetaMask, languages like Solidity, and frameworks like Truffle. This familiarity considerably simplifies the event course of. Value Effectivity: By reducing fuel charges and rising throughput, Linea is ready to supply an economical resolution for each builders and finish customers. This effectivity is especially advantageous for micro-transactions and dapps with a big person base. Scalability: Linea is designed to deal with extra transactions per second than Ethereum, enhancing the community’s scalability. This makes Linea a great platform for dapps requiring excessive throughputs, comparable to DeFi platforms and Web3 video games. Safety: As an L2 scaling resolution, Linea advantages from the safety of the Ethereum mainnet, guaranteeing that every one transactions are processed safely.

Introducing Moralis – The Best Method to Construct Dapps on Linea
The best strategy to construct dapps on Linea is to leverage a Web3 knowledge supplier like Moralis. In our suite of industry-leading improvement instruments, you’ll discover nodes for all main blockchain networks and 10+ use case-specific APIs. This contains our premier NFT API, Pockets API, Token API, Worth API, and plenty of others. As such, whether or not you’re trying to construct an NFT market, cryptocurrency pockets, or some other dapps for the Linea community, we have now acquired you lined!

However why must you use Moralis to construct dapps on Linea?
Complete: Moralis gives the {industry}’s most detailed API responses, permitting you to entry in depth knowledge with fewer calls. Fetch data from each on- and off-chain sources with a single API request, making your dapp improvement extra environment friendly. Easy: With full cross-chain compatibility, Moralis affords full function parity throughout all main blockchains, together with Linea, Ethereum, and Polygon. This unified toolkit streamlines your developer expertise, that means you don’t should hassle with a brand new supplier for every chain you work together with. Safe: Moralis units the gold commonplace for enterprise-grade knowledge safety. We’re proud to be the one SOC 2 Kind 2 licensed Web3 infrastructure supplier within the {industry}, guaranteeing the very best degree of safety on your tasks.
Moralis Web3 APIs – Finest Instruments to Construct Dapps on Linea
The best strategy to construct dapps on Linea is to leverage our premier Web3 APIs, permitting you to seamlessly streamline on-chain knowledge integration on your tasks with just a few strains of code. As a result of in depth variety of specialised interfaces provided by Moralis, we gained’t have the ability to cowl all of them on this information. As such, we’ll as a substitute introduce you to 3 outstanding examples:
Pockets APIToken APINFT API
When you’d prefer to discover all our Linea-compatible interfaces, please try our Web3 API web page, the place you’ll discover the remainder!
Pockets API
Moralis’ Pockets API is the {industry}’s main software for accessing pockets knowledge. With this premier interface, you’ll be able to seamlessly fetch any pockets’s historical past, token balances, web price, profitability, and far more with only a single API name. So, whether or not you’re constructing crypto wallets, portfolio trackers, or different dapps on Linea, the Pockets API makes it straightforward!

To show the facility of the Pockets API, right here’s an instance of how one can fetch a pockets’s total historical past with one endpoint:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(‘https://deep-index.moralis.io/api/v2.2/wallets/0x5856EDF9212bdceC74301ec78AFc573B62D6A283/historical past?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
By calling the endpoint above, you’ll obtain the total historical past of the pockets. Moreover, the response is enriched with automated class tags, summaries, and extra, offering totally decoded knowledge proper out of the field. Right here’s an instance of what the response may appear like:
{
//…
“consequence”: [
{
//…
“native_transfers”: [
{
“from_address”: “0x53d3801bc009867485eb69e6178e1c0deca3fddc”,
“from_address_label”: null,
“to_address”: “0xde1e598b81620773454588b85d6b5d4eec32573e”,
“to_address_label”: null,
“value”: “9223865045570189”,
“value_formatted”: “0.009223865045570188”,
“direction”: “send”,
“internal_transaction”: false,
“token_symbol”: “ETH”,
“token_logo”: “https://cdn.moralis.io/eth/0x.png”
}
],
“abstract”: “Despatched 0.009224 ETH to 0xde…573e”,
“possible_spam”: false,
“class”: “ship”
},
//…
]
}
Discover our official Pockets API documentation to find different endpoints you should utilize to construct dapps on Linea!
Token API
The Token API is the main software in Web3 for fetching ERC-20 knowledge. With this top-tier interface, you’ll be able to simply get token balances, metadata, homeowners, costs, and extra utilizing only a single line of code. Consequently, this highly effective software lets you effortlessly create a variety of dapps, from token explorers like Moralis Cash to decentralized exchanges (DEXs) like Uniswap.

To show the accessibility of our Token API, let’s take a fast take a look at our endpoint for fetching balances with costs:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(‘https://deep-index.moralis.io/api/v2.2/wallets/0x5856EDF9212bdceC74301ec78AFc573B62D6A283/tokens?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
By calling the script above, you’ll obtain an array of all tokens held by the required pockets. Moreover, the response is enriched with costs, worth modifications over time, and extra particulars for every token. Right here’s an instance of what the response may appear like:
{
//…
“consequence”: [
{
“token_address”: “0xa219439258ca9da29e9cc4ce5596924745e12b93”,
“symbol”: “USDT”,
“name”: “Tether USD”,
“logo”: null,
“thumbnail”: null,
“decimals”: 6,
“balance”: “542905179549”,
“possible_spam”: false,
“verified_contract”: false,
“total_supply”: “15290859809510”,
“total_supply_formatted”: “15290859.80951”,
“percentage_relative_to_total_supply”: 3.5505209406952085,
“balance_formatted”: “542905.179549”,
“usd_price”: 0.9998899192502502,
“usd_price_24hr_percent_change”: -0.011008074974938614,
“usd_price_24hr_usd_change”: -0.00011008074974938609,
“usd_value”: 542845.4161397922,
“usd_value_24hr_usd_change”: -59.76340920757502,
“native_token”: false,
“portfolio_percentage”: 58.9964
},
//…
]
}
Discover our Token API documentation to study extra about our different endpoints!
NFT API
Moralis’ NFT API is the very best software for accessing NFT knowledge. This premier interface lets you get hold of NFT balances, metadata, costs, and far more with single endpoints. This makes it the right API for constructing NFT marketplaces, Web3 video games, and different dapps that depend on NFT knowledge!

To focus on the advantages of the NFT API, let’s check out our endpoint for fetching balances:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(‘https://deep-index.moralis.io/api/v2.2/0x1F5876Da8Ed41b8DB49b9A82EA690fd8011394d1/nft?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Calling the endpoint above will give you an array of NFTs held by the required pockets. Right here’s an instance of what the response may appear like:
{
//…
“consequence”: [
{
“amount”: “1”,
“token_id”: “4”,
“token_address”: “0x0872ec4426103482a50f26ffc32acefcec61b3c9”,
“contract_type”: “ERC1155”,
“owner_of”: “0x1f5876da8ed41b8db49b9a82ea690fd8011394d1”,
“last_metadata_sync”: “2024-05-23T08:08:31.529Z”,
“last_token_uri_sync”: “2024-05-23T08:08:31.454Z”,
“metadata”: “{“name”:”Linea Voyage – Delta Edition”,”description”:”The Delta Edition represents the inception of the network, the moment of instantiation of the testnet and activation of the community effort, sending waves of energy throughout the network, and setting into motion the potential to come.”,”image”:”ipfs://Qmb31479z12SzfoskmhN2KRHRtZ3fnmm3TKeET4VtXs1Q9″,”animation_url”:”ipfs://Qmdu7CwEP5dSm5Y7iyV8AhPdJygpKkKeyqA1SyVezVkdHD”,”attributes”:[{“trait_type”:”Tier”,”value”:”4″}]}”,
“block_number”: “3912275”,
“block_number_minted”: null,
“identify”: “Linea Voyage”,
“image”: “VOYAGE”,
“token_hash”: “9fb8de84306e2d372edcf8f25f058d00”,
“token_uri”: “https://ipfs.moralis.io:2053/ipfs/QmfFuKPuUPyPMytHvhfBHcspqBSw4sQsXsbmhAFDVrTJUL”,
“minter_address”: “ERC1155 tokens haven’t got a single minter”,
“verified_collection”: false,
“possible_spam”: false,
“collection_logo”: null,
“collection_banner_image”: null
},
//…
]
}
To study extra about our different endpoints, please go to the official NFT API documentation web page!
3-Step Tutorial: The way to Construct Dapps on Linea with Moralis
Now that you’ve explored the very best instruments for constructing dapps on Linea, we’ll information you thru a tutorial on the way to use them. Particularly, we’ll present you the way to get the native stability of any tackle in three easy steps utilizing our Pockets API:
Step 1: Receive Your Moralis API KeyStep 2: Write a Script to Name Our Native Stability EndpointStep 3: Run the Code
Nevertheless, earlier than continuing, let’s cowl some vital conditions!
Stipulations
To observe together with the steps beneath, guarantee you’ve gotten the next conditions prepared:
Step 1: Receive Your Moralis API Key
When you haven’t already, register for a free account with Moralis by clicking the “Begin for Free” button on the high proper:

As soon as logged in, navigate to the “Dwelling” tab to seek out your API key:

Copy and save the important thing for now, as you’ll want it within the second step!
Step 2: Write a Script Calling the Native Balances Endpoint
Open your most popular IDE, arrange a folder, and initialize a undertaking utilizing the next terminal command:
npm init
Set up the required dependencies by operating the terminal command beneath:
npm set up node-fetch –save
npm set up moralis @moralisweb3/common-evm-utils
Add “kind”: “module” to the ”package deal.json” file:

Create a brand new ”index.js” file and add the next code:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOU_API_KEY’
},
};
fetch(‘https://deep-index.moralis.io/api/v2.2/0x2898730f10411D6E92cad809e78cc3a7Ea82C695/stability?chain=eth’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Substitute YOUR_API_KEY together with your Moralis API key and configure the tackle parameter to suit your question:

That’s it for the code! All that continues to be now’s to run the script!
Step 3: Run the Code
Open a brand new terminal, navigate to your undertaking’s root folder, and run the enter beneath to execute the script:
node index.js
In return, you’ll get the native stability of the required pockets. Right here’s an instance of what it would appear like:
{ stability: ‘904846316993485’ }
That’s it! Getting on-chain knowledge doesn’t should be tougher than this when utilizing Moralis. From right here, you’ll be able to observe the identical steps to name any of our different endpoints. With these instruments, you now have the whole lot it’s essential to construct superb dapps on Linea!
Abstract: The way to Construct Dapps on Linea
When constructing dapps on Linea, you want a seamless strategy to combine on-chain knowledge into your undertaking. Nevertheless, doing so from scratch is a bothersome and time-consuming course of. It requires organising an underlying infrastructure and manually aggregating and decoding the info. Thankfully, now you can streamline the method with a Web3 knowledge supplier like Moralis!

Moralis gives the instruments it’s essential to seamlessly combine on-chain knowledge into your dapps. Our complete toolkit contains nodes for over 20 networks and greater than ten use case-specific APIs, such because the Token API, Pockets API, and Streams API.
Right here’s why it is best to construct dapps on Linea with Moralis:
Complete: Our outcome-driven APIs present extra knowledge with fewer API calls in comparison with the competitors, making your dapp improvement on Linea extra environment friendly. Cross-Chain: Our API suite is totally cross-chain appropriate, eliminating the necessity for a brand new supplier for every blockchain you work together with. The supported networks embody Linea, Ethereum, Polygon, BSC, Optimism, Arbitrum, Avalanche, and plenty of extra. Safe: Moralis is the one SOC 2 Kind 2 licensed Web3 infrastructure supplier, guaranteeing enterprise-grade knowledge safety.
So, for those who’d like to begin constructing dapps on Linea your self, bear in mind to enroll with Moralis. You possibly can create an account without cost, and also you’ll acquire on the spot entry to our top-tier APIs and nodes!
Moreover, for those who’re severe about constructing dapps on Linea, make sure to try different instruments provided by Moralis. As an example, to get free testnet tokens you should utilize throughout your improvement endeavors, be sure to take a look at our Linea Goerli faucet article now!