Are you trying to find the simplest strategy to run Fantom RPC nodes? In that case, look no additional! In at this time’s tutorial, we’ll present you how you can arrange a Fantom node totally free utilizing Moralis, the {industry}’s foremost node supplier. With our easy-to-use interface, now you can arrange nodes for 35+ chains with the clicking of a button. Are you desperate to be taught extra? Take a look at our transient abstract of all the course of under:
Step 3: Choose “Fantom”, then “Mainnet”, and press the “Create Node” button:
![Arrows pointing at the configurations for creating Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Configurations.png)
In return, you’ll get two URLs in your Fantom RPC nodes that you may copy and combine into your tasks to work together with the blockchain:
![Red arrows pointing at the copy buttons for Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-URLs.png)
That’s it! It’s tremendous simple to arrange Fantom nodes when leveraging Moralis. Nevertheless, when you’re in search of a extra in-depth walkthrough of the steps above, additional details about the chain, and a tutorial on how you can name your Fantom RPC nodes, then stick round as we cowl all of it on this information!
Prepared to right away arrange your personal Fantom node? In that case, don’t overlook to register an account with Moralis. Doing so offers you rapid entry to all our industry-leading instruments so you’ll be able to streamline your developer expertise at this time!
Overview
Are you seeking to run Fantom RPC nodes by yourself? In that case, you would possibly wish to rethink. Organising a Fantom node from scratch may be fairly a tedious process. It requires a posh underlying infrastructure that calls for quite a lot of bandwidth, computational energy, and storage capability, which takes time to arrange and preserve. Luckily, now you can keep away from all related challenges with a node supplier like Moralis!
![](https://moralis.io/wp-content/uploads/2024/05/Blog-Moralis-Logo-1.png)
At Moralis, we deal with all of the underlying complexities of working blockchain nodes. In return, you need to use our user-friendly interface to arrange nodes for 35+ chains with the clicking of a button. Wish to be taught extra about how this works? Be a part of us on this information as we present you how you can arrange your very personal Fantom node totally free. Let’s dive straight in!
What’s Fantom?
Fantom is a permissionless, decentralized, open-source good contract platform designed for digital property and decentralized purposes (dapps). Launched in 2019, Fantom goals to supply an alternative choice to Ethereum by addressing the blockchain trilemma. As such, its structure is crafted to stability safety, scalability, and decentralization, making it a strong answer for varied blockchain wants.
![Fantom blockchain network.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-What-Is-Fantom.png)
However why do you have to construct on Fantom? Listed below are 4 key advantages of the community:
Excessive-Pace Transactions: Fantom presents near-instant transaction finality, considerably enhancing the effectivity and consumer expertise of Web3 platforms. EVM Compatibility: Totally suitable with the Ethereum Digital Machine (EVM), Fantom permits builders to make use of acquainted Ethereum instruments, frameworks, and programming languages when constructing dapps for the community. Scalability & Safety: Fantom’s modern consensus mechanism and sturdy structure present a safe and scalable atmosphere for blockchain-based tasks, making it an amazing selection for builders. In depth Ecosystem: Fantom helps an enormous ecosystem of dapps throughout varied industries, together with finance, gaming, DeFi, and extra.
What are Fantom RPC Nodes?
Fantom RPC nodes are servers, computer systems, and different gadgets accountable for storing knowledge, validating transactions, propagating blocks, and rather more. The Fantom blockchain consists of hundreds of those nodes that collectively uphold the community’s safety, operations, and effectivity.
![A collection of Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes.png)
So, what are Fantom RPC nodes used for?
Information Storage: Nodes retailer blockchain knowledge. Some retailer all the historical past of the community, whereas others retailer solely the latest blocks. Transaction Validation: Fantom nodes are accountable for validating transactions and propagating new blocks throughout the community. Web3 Growth: Nodes function gateways to the Fantom community, facilitating each the studying and writing of on-chain knowledge. This makes them important for creating dapps.
This overview highlights the essential roles of Fantom RPC nodes. Within the subsequent part, we’ll introduce you to Moralis, which is the simplest strategy to arrange a Fantom node totally free!
Introducing Moralis – The Best Method to Arrange a Fantom Node
Moralis is the Web3 {industry}’s most outstanding node supplier. With our intuitive consumer interface, you’ll be able to seamlessly run blockchain nodes for 35+ chains on the click on of some buttons. As such, it has by no means been simpler to arrange a Fantom node than when working with Moralis!
![Text: "Ultimate RPC Nodes for Web3"](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Moralis-Nodes.jpg)
However why select Moralis?
Pace: Our nodes boast fast response instances from 70 ms, guaranteeing you get the information you want immediately. Reliability: We provide a formidable 99.9% uptime for all RPC nodes, constructed to the very best reliability requirements. Safety: Moralis is the one Web3 infrastructure supplier with SOC 2 Kind 2 certification, guaranteeing top-notch knowledge safety.
That provides you a fast introduction to our node service. Within the subsequent part, we’ll present you how you can arrange your personal Fantom node totally free utilizing Moralis!
3-Step Tutorial: Set Up a Fantom Node for Free
We’ll now present you how you can arrange a Fantom node utilizing Moralis. And because of the accessibility of our premier service, you are able to do so in three easy steps:
Signal Up with MoralisConfigure Your NodeIntegrate Your Node
Step 1: Signal Up with Moralis
To get began, step one is to enroll with Moralis. To take action, merely click on the “Begin for Free” button situated on the high proper nook of the web page:
![](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Sign-Up-With-Moralis.png)
Step 2: Configure Your Node
Go to “https://admin.moralis.io/nodes” and click on “+ Create Node”:
![Red arrow pointing at "+ Create Node" button.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Create-Node.png)
Choose “Fantom”, adopted by “Mainnet”, and hit “Create Node”:
![Arrows pointing at the configurations for creating Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Configurations-1024x553.png)
Step 3: Combine Your Node
Copy one of many URLs in your Fantom RPC nodes and combine it into your venture to work together with the chain:
![Red arrows pointing at the copy buttons for Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-URLs.png)
That’s it; establishing a Fantom node is straightforward when utilizing Moralis!
How To Name Your Fantom RPC Nodes
Together with your Fantom RPC nodes up and working, we’ll now present you how you can use them in apply. Extra particularly, we’ll reveal how you can fetch the native stability of a Fantom pockets utilizing Ethers.js.
Nevertheless, earlier than you get began, be sure to have the next prepared:
From right here, now you can observe the 5 steps under:
Step 1: Open your most popular built-in improvement atmosphere (IDE), arrange a brand new folder, launch the terminal, and initialize a venture with this command:npm init Step 2: Set up Ethers.js with the next terminal command:npm set up ethers Step 3: Open “bundle.json” and add “sort”: “module” to the checklist:
!["type": "module" is highlighted in the code editor.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Type-Module.png)
Step 4: Create a brand new “index.js” file and add the next code:import { ethers } from “ethers”;
const supplier = new ethers.suppliers.JsonRpcProvider(“YOUR_NODE_URL”);
const handle = “0xFC00FACE00000000000000000000000000000000”;
const stability = await supplier.getBalance(handle);
console.log(“Stability: “, ethers.utils.formatEther(stability));
Change YOUR_NODE_URL with one of many URLs out of your Fantom RPC nodes and configure the handle parameter to suit your request:
![](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Configure-Code-1024x292.png)
Step 5: Execute the script with this terminal command:node index.js
In return, you’ll get the stability displayed within the console. It ought to look one thing like this:
Stability: 1376515028.186726979773209772
Congratulations! You now know how you can fetch knowledge seamlessly utilizing your Fantom RPC nodes!
Nevertheless, if you would like a extra in-depth walkthrough of the above steps, together with further examples of the kinds of knowledge you may get along with your nodes, take a look at the Moralis YouTube video under:
Exploring the Limitations of Fantom RPC Nodes
Whereas querying knowledge utilizing RPC nodes is feasible, it’s essential to know their limitations. As such, let’s discover three main drawbacks of utilizing nodes:
Chain-Particular: Blockchain nodes are tied to a particular community, that means you must run and preserve a node for every chain you propose to work together with. This could grow to be costly and resource-intensive, particularly when you’re constructing cross-chain dapps. Complicated to Question: Nodes don’t help simple queries similar to, “What tokens does handle X maintain?” To get this information, you must make a number of requests and manually compile the information. Uncooked Information: Nodes present uncooked blockchain knowledge that must be decoded, interpreted, and formatted earlier than it turns into helpful. This course of may be each time- and resource-intensive.
![Cluster of Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Limitations.png)
So, what’s the choice?
A extra environment friendly choice for querying on-chain knowledge is utilizing Moralis’ Web3 APIs. These premier interfaces help you question decoded knowledge with single API calls, saving you effort and time. To be taught extra about how Moralis can streamline your workflow, be a part of us within the subsequent part!
Past Fantom RPC Nodes – Diving Deeper Into Moralis
Moralis is an industry-leading Web3 API supplier, supplying you with over ten specialised interfaces for all main use circumstances. Some outstanding examples embody the NFT API, Pockets API, Token API, and plenty of extra. With these instruments, you’ll be able to effortlessly fetch decoded knowledge with single strains of code in your wallets, portfolio trackers, decentralized exchanges (DEXs), or some other Web3 platforms you could be constructing!
![](https://moralis.io/wp-content/uploads/2024/06/Blog-Moralis-Logo-2.png)
However what makes our APIs industry-leading?
One API – All of the Information: Moralis’ Web3 APIs are outcome-oriented, designed to attenuate the requests you must construct subtle dapps. Get knowledge from each on-chain and off-chain sources in a single request. Streamlined Developer Expertise: Our APIs are actually cross-chain suitable, providing you with full characteristic parity throughout all main chains, together with Fantom, Ethereum, Polygon, and plenty of extra. As such, when utilizing Moralis, you’ll be able to streamline your developer expertise as you don’t need to combine a brand new supplier for every chain you propose to work together with. Trusted by Trade Leaders: Moralis is used and trusted by among the largest names in Web3, together with MetaMask, Opera, and Blockchain.com.
That provides you a quick overview of Moralis. Let’s now dive a bit deeper into our suite of Web3 APIs and take a more in-depth have a look at three outstanding interfaces!
Pockets API
Moralis’ Pockets API presents a strong suite of options, distinctive flexibility, and unmatched scalability. Additionally, it helps over 500 million addresses throughout main blockchain networks, together with Fantom, Ethereum, BSC, and plenty of others, making it a really perfect software for creating cryptocurrency wallets.
![](https://moralis.io/wp-content/uploads/2024/06/Blog-Moralis-Wallet-API.png)
With the Pockets API, you’ll be able to effortlessly retrieve a pockets’s historical past, token balances, profitability, internet value, and extra by means of ready-to-use endpoints. To reveal the accessibility and energy of this software, let’s discover the Pockets Historical past endpoint for instance.
With only a single line of code, you’ll be able to receive a complete historical past of a pockets, full with computerized class tags, occasion summaries, and extra. Right here’s what it would appear like:
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/0xF977814e90dA44bFA03b6295A0616a897441aceC/historical past?chain=0xfa’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Response:
{
[
{
“hash”: “0x35945e38cb85972ca9e71160e23a75ae2cdf3caf8709642e2e1251d42de5eea2”,
“nonce”: “1559323”,
“transaction_index”: “3”,
“from_address”: “0xebf4fbb9c81b84dd5cf89bc75588e5d0018501b3”,
“from_address_label”: null,
“to_address”: “0x2f6f07cdcf3588944bf4c42ac74ff24bf56e7590”,
“to_address_label”: “StargateToken (STG)”,
//…
“erc20_transfers”: [
{
“token_name”: “StargateToken”,
“token_symbol”: “STG”,
“token_logo”: “https://logo.moralis.io/0xfa_0x2f6f07cdcf3588944bf4c42ac74ff24bf56e7590_d6716573db024088ab4aab0e69aa976f”,
“token_decimals”: “18”,
“from_address”: “0xebf4fbb9c81b84dd5cf89bc75588e5d0018501b3”,
“from_address_label”: null,
“to_address”: “0xf977814e90da44bfa03b6295a0616a897441acec”,
“to_address_label”: null,
“address”: “0x2f6f07cdcf3588944bf4c42ac74ff24bf56e7590”,
“log_index”: 4,
“value”: “5526914355000000000000000”,
“possible_spam”: false,
“verified_contract”: true,
“direction”: “receive”,
“value_formatted”: “5526914.355”
}
],
“native_transfers”: [],
“abstract”: “Obtained 5,526,914.35 STG from 0xeb…01b3”,
“possible_spam”: false,
“class”: “token obtain”
},
//…
]
}
Go to our Pockets API web page to find extra concerning the capabilities of this industry-leading software!
Token API
The Token API helps each single token throughout all the most important chains. This contains stablecoins, meme cash, and the whole lot in between. As such, with this software, you’ll be able to seamlessly streamline ERC-20 knowledge integration for all of your dapps with out breaking a sweat.
![](https://moralis.io/wp-content/uploads/2024/05/Blog-Token-API.png)
With Moralis’ Token API, you solely want a number of strains of code to get token balances, transfers, liquidity knowledge, metadata, and rather more. To focus on the accessibility of this software, we’ll have a look at our Token Balances with Costs endpoint for instance.
With only one name, you may get any pockets’s token balances with costs. Right here’s what it would appear like:
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/0xF977814e90dA44bFA03b6295A0616a897441aceC/tokens?chain=0xfa’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Response:
{
//…
“end result”: [
{
“token_address”: “0x2f6f07cdcf3588944bf4c42ac74ff24bf56e7590”,
“symbol”: “STG”,
“name”: “StargateToken”,
“logo”: “https://logo.moralis.io/0xfa_0x2f6f07cdcf3588944bf4c42ac74ff24bf56e7590_d6716573db024088ab4aab0e69aa976f”,
“thumbnail”: “https://logo.moralis.io/0xfa_0x2f6f07cdcf3588944bf4c42ac74ff24bf56e7590_d6716573db024088ab4aab0e69aa976f”,
“decimals”: 18,
“balance”: “5526914355000000000000000”,
“possible_spam”: false,
“verified_contract”: true,
“total_supply”: “23157352728493329565962830”,
“total_supply_formatted”: “23157352.72849332956596283”,
“percentage_relative_to_total_supply”: 23.86677967814326,
“balance_formatted”: “5526914.355”,
“usd_price”: 0.40294395256782295,
“usd_price_24hr_percent_change”: 9.211802565854372,
“usd_price_24hr_usd_change”: 0.03398753659359799,
“usd_value”: 2227036.71570754,
“usd_value_24hr_usd_change”: 187846.2038902447,
“native_token”: false,
“portfolio_percentage”: 3.3397
},
//…
]
}
Take a look at our Token API web page to be taught extra concerning the options and advantages of this premier software!
NFT API
Moralis’ NFT API powers among the largest names in Web3, together with MetaMask, Delta, and plenty of extra. This premier interface helps over three million NFT collections throughout the most important chains, from established tasks like Pudgy Penguins to tokens that dropped simply seconds in the past.
![](https://moralis.io/wp-content/uploads/2024/05/Blog-Moralis-NFT-API.png)
With the NFT API, you’ll be able to seamlessly fetch NFT metadata, costs, balances, and rather more. As such, this interface offers you with the instruments to construct highly effective NFT-based tasks. And to present you an instance, we’ll discover our NFT Stability endpoint.
With only one line of code, you’ll be able to effortlessly get the NFT stability of any pockets. Right here’s what it will possibly appear like:
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/0x727a10ae1afc91754d357b4748f6d793c9795026/nft?chain=0xfa’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Response:
{
//…
“end result”: [
{
“amount”: “1”,
“token_id”: “207”,
“token_address”: “0xff35b597f47bbf952457c076e6b01480c896c1dc”,
“contract_type”: “ERC721”,
“owner_of”: “0x727a10ae1afc91754d357b4748f6d793c9795026”,
“last_metadata_sync”: “2024-03-10T16:00:30.761Z”,
“last_token_uri_sync”: “2024-03-10T16:00:29.971Z”,
“metadata”: “{“name”:”Puff Panda”,”description”:”This Panda can puff, puff pass with the best”,”image”:”ipfs://QmZJfA4XwLAAy1YGJcbcUs5W6UidnxBnApG37FqL4mCvg9/puff-panda.png”,”attributes”:{“bunnyId”:”0″}}”,
“block_number”: “34967253”,
“block_number_minted”: “34967253”,
“name”: “True Degenerates”,
“symbol”: “TD”,
“token_hash”: “3e4fdaf920a0c777bc4e4a7a777ced5f”,
“token_uri”: “https://ipfs.moralis.io:2053/ipfs/QmTqStASCgUuW1Qz6mL5rZPKgsJCxbijWYGnbcXAwu22sL/puff-panda.json”,
“minter_address”: “0x727a10ae1afc91754d357b4748f6d793c9795026”,
“verified_collection”: false,
“possible_spam”: false,
“collection_logo”: null,
“collection_banner_image”: null
},
]
}
Go to our NFT API web page to be taught extra about this premier interface!
Abstract: Run Fantom RPC Nodes with Moralis
Organising a Fantom node by yourself could be a bothersome process. It requires a sophisticated underlying infrastructure that wants quite a lot of computational energy, storage capability, and bandwidth, which takes money and time to arrange. Luckily, now you can circumvent all related challenges with a node supplier like Moralis!
At Moralis, we deal with all of the underlying complexities for you. In return, you need to use our easy point-and-click interface to run nodes for 35+ chains, together with Fantom, on the click on of a button. Right here’s a fast breakdown of the way it works:
![Red arrow pointing at "+ Create Node" button.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Create-Node.png)
Step 3: Choose “Fantom”, adopted by “Mainnet”, and click on “Create Node”:
![Arrows pointing at the configurations for creating Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-Configurations.png)
In return, you’ll get two URLs in your Fantom RPC nodes:
![Red arrows pointing at the copy buttons for Fantom RPC nodes.](https://moralis.io/wp-content/uploads/2024/07/Blog-Fantom-RPC-Nodes-URLs.png)
That’s it! Organising Fantom RPC nodes is easy when leveraging Moralis!
If you happen to appreciated this Fantom RPC nodes tutorial, contemplate testing extra content material right here on the weblog. Listed below are a number of related articles:
Additionally, if you wish to run your personal Fantom RPC nodes, bear in mind to register an account with Moralis. You’ll be able to join free, and also you’ll get rapid entry to our industry-leading improvement instruments!