An Introduction to Geth and Running Ethereum Nodes

Share this article

Crypto Markets

In this article, we’ll look at what Ethereum nodes are, and explore one of the most popular ones, called Geth.

In order to communicate with the blockchain, we must use a blockchain client. The client is a piece of software capable of establishing a p2p communication channel with other clients, signing and broadcasting transactions, mining, deploying and interacting with smart contracts, etc. The client is often referred to as a node.

The formal definition of the functionality an Ethereum node must follow is defined in the ethereum yellow paper. The yellow paper defines the required functions of nodes on the network, the mining algorithm, private/public key ECDSA parameters. It defines the entirety of features which make nodes fully compatible Ethereum clients.

Based on the yellow paper, anyone is able to create their own implementation of an Ethereum node in whatever language they see fit.

A full list of clients can be seen here.

The most popular clients so far are Geth and Parity. The implementations differ mostly by the programming language of choice — where Geth uses Golang and Parity uses Rust.

Since Geth is the most popular client implementation currently available, we’ll focus on it for now.

Types of Nodes

When you’re joining the Ethereum network, you have an option of running various types of nodes. The options currently are:

  • Light node
  • Full node
  • Archive node

An archive node is a special case of a full node, so we won’t go into detail on it. One of the best summaries on the types of nodes I’ve found is on Stack Exchange:

In general, we can divide node software into two types: full nodes and light(weight) nodes. Full nodes verify block that is broadcast onto the network. That is, they ensure that the transactions contained in the blocks (and the blocks themselves) follow the rules defined in the Ethereum specifications. They maintain the current state of the network (as defined according to the Ethereum specifications).

Transactions and blocks that do not follow the rules are not used to determine the current state of the Ethereum network. For example, if A tries to send 100 ether to B but A has 0 ethers and a block includes this transaction, the full nodes will realize this does not follow the rules of Ethereum and reject that block as invalid. In particular, the execution of smart contracts is an example of a transaction. Whenever a smart contract is used in a transaction (e.g., sending ERC-20 tokens), all full nodes will have to run all the instructions to ensure that they arrive at the correct, agreed-upon next state of the blockchain.

There are multiple ways of arriving at the same state. For example, if A had 101 ether and gave a hundred of them to B in one transaction paying 1 ether for gas, the end result would be the same as if A sent 100 transactions of 1 ether each to B paying 0.01 ether per transaction (ignoring who received the transaction fees). To know if B is now allowed to send 100 ether, it is sufficient to know what B’s current balance is. Full nodes that preserve the entire history of transactions are known as full archiving nodes. These must exist on the network for it to be healthy.

Nodes may also opt to discard old data; if B wants to send 100 ether to C, it doesn’t matter how the ether was obtained, only that B’s account contains 100 ether. Light nodes, in contrast, do not verify every block or transaction and may not have a copy of the current blockchain state. They rely on full nodes to provide them with missing details (or simply lack particular functionality). The advantage of light nodes is that they can get up and running much more quickly, can run on more computationally/memory constrained devices, and don’t eat up nearly as much storage. On the downside, there is an element of trust in other nodes (it varies based on client and probabilistic methods/heuristics can be used to reduce risk). Some full clients include features to have faster syncs (e.g., Parity’s warp sync).

Installing Geth

The installation instructions for Geth on various platforms (Windows, macOS, Linux) can be found here. The list is quite comprehensive and kept up to date, so I won’t go over it in the article.

Running Geth

In order to spin up a Geth node, the only thing you need to do is go to your terminal window and run geth. When you do it, you should get an output similar to this:

➜  ~ geth
INFO [06-03|11:03:13] Maximum peer count                       ETH=25 LES=0 total=25
INFO [06-03|11:03:13] Starting peer-to-peer node               instance=Geth/v1.8.10-stable/darwin-amd64/go1.10.2
INFO [06-03|11:03:13] Allocated cache and file handles         database=/Users/mjvr/Library/Ethereum/geth/chaindata cache=768 handles=128
INFO [06-03|11:03:13] Writing default main-net genesis block
INFO [06-03|11:03:14] Persisted trie from memory database      nodes=12356 size=2.34mB time=48.31016ms gcnodes=0 gcsize=0.00B gctime=0s livenodes=1 livesize=0.00B
INFO [06-03|11:03:14] Initialised chain configuration          config="{ChainID: 1 Homestead: 1150000 DAO: 1920000 DAOSupport: true EIP150: 2463000 EIP155: 2675000 EIP158: 2675000 Byzantium: 4370000 Constantinople: <nil> Engine: ethash}"
INFO [06-03|11:03:14] Disk storage enabled for ethash caches   dir=/Users/mjvr/Library/Ethereum/geth/ethash count=3
INFO [06-03|11:03:14] Disk storage enabled for ethash DAGs     dir=/Users/mjvr/.ethash                      count=2
INFO [06-03|11:03:14] Initialising Ethereum protocol           versions="[63 62]" network=1
INFO [06-03|11:03:14] Loaded most recent local header          number=0 hash=d4e567…cb8fa3 td=17179869184
INFO [06-03|11:03:14] Loaded most recent local full block      number=0 hash=d4e567…cb8fa3 td=17179869184
INFO [06-03|11:03:14] Loaded most recent local fast block      number=0 hash=d4e567…cb8fa3 td=17179869184
INFO [06-03|11:03:14] Regenerated local transaction journal    transactions=0 accounts=0
INFO [06-03|11:03:14] Starting P2P networking
INFO [06-03|11:03:16] UDP listener up                          self=enode://a4cb08519bc2bceecb8ad421871c624d5212888653bbaee309fda960f3c87ca7aa9855ee14684d521836ae88ad1986b8ca944348e976760d2bd1247ed3ca7628@[::]:30303
INFO [06-03|11:03:16] RLPx listener up                         self=enode://a4cb08519bc2bceecb8ad421871c624d5212888653bbaee309fda960f3c87ca7aa9855ee14684d521836ae88ad1986b8ca944348e976760d2bd1247ed3ca7628@[::]:30303
INFO [06-03|11:03:16] IPC endpoint opened                      url=/Users/mjvr/Library/Ethereum/geth.ipc

After this, you should see new lines appear periodically, where Geth says “Importing new state” or “Importing new block headers” or “Importing new receipts”. The state, block headers and transactions are part of Ethereum’s tree tries: they must be downloaded in order to synchronize your node with the Ethereum blockchain.

This is a process which can take a really long time, so one of the options you have is to run a light node like this;

geth --light

What Geth needs to do now is only pull the latest block headers and rely on other full nodes to validate transactions through the usage of merkle proofs.

Accessing a Geth Console

Now that you’ve created a node, you can access it by opening up a new tab in your terminal and running the following:

geth attach

This will connect a Geth console — which is a Javascript environment for communicating with the blockchain — to your running node. This can be done in both the full client mode and the light mode.

After you’ve opened the console, type this:


You should get an output as a number (e.g. 5631487) which represents the current block number of the Ethereum network.

Creating a New Account

In order to use the blockchain, you need to have an account. With Geth, you can do it by running the following in your terminal:

geth account new

After you’ve done that, it will ask you for the password, which you’ll need to protect your account. Make sure to use a secure password and to store it safely.

What Geth does when you run geth account new is update a file in the Geth data directory (a directory where Geth stores all the necessary data, including blocks and headers). The locations are (per platform):

  • macOS: ~/Library/Ethereum
  • Linux: ~/.ethereum
  • Windows: %APPDATA%\Ethereum

Accessing Geth from Other Clients

When you start Geth, the client automatically starts an RPC server at port 8545. You can access the RPC server and its methods on this port by connecting to localhost:8545 with a library like web3js or web3j or call it manually with curl or wget.

To learn about connecting with external tools like those to a running Geth instance (either private when launching your own blockchain, or public as in the instructions above) see this post.


In this short introduction we covered Geth, the types of Ethereum nodes, and their purpose. You can now run a Geth node of your own, and enhance it with third-party tools. In future articles, we’ll cover running private networks (your own Ethereum blockchain with Geth) and much more.

Frequently Asked Questions (FAQs) about Geth and Running Ethereum Nodes

What is the difference between Geth and Ethereum?

Geth is a command-line interface for running a full Ethereum node implemented in Go. It allows you to connect to the Ethereum network, execute smart contracts, mine ether, and transfer funds between addresses. On the other hand, Ethereum is a decentralized, open-source blockchain featuring smart contract functionality. It is the platform on which Geth operates, allowing it to interact with Ethereum’s core blockchain infrastructure.

How can I install Geth on my system?

Geth can be installed on various operating systems including Windows, Linux, and macOS. The installation process involves downloading the appropriate Geth client for your operating system from the official Geth download page, and then following the installation instructions provided. It’s important to ensure that your system meets the necessary requirements before starting the installation process.

How can I start mining with Geth?

To start mining with Geth, you first need to create an account and start the Ethereum node. Once the node is up and running, you can start the miner with the ‘miner.start()’ command. It’s important to note that mining requires a significant amount of computational power and may not be feasible on all systems.

What are the system requirements for running a Geth node?

Running a Geth node requires a system with at least 4GB of memory, a modern multi-core processor, and a high-speed internet connection. Additionally, you’ll need sufficient storage space to store the entire Ethereum blockchain, which is currently over 200GB in size and growing.

How can I interact with the Ethereum network using Geth?

Geth provides a JavaScript console that allows you to interact with the Ethereum network. You can use this console to execute smart contracts, transfer funds, and perform other operations on the Ethereum blockchain. The console can be accessed by starting Geth with the ‘console’ command.

What is the role of Geth in the Ethereum ecosystem?

Geth plays a crucial role in the Ethereum ecosystem as it allows users to participate in the Ethereum network. By running a Geth node, users can mine ether, execute smart contracts, and make transactions on the Ethereum blockchain. Geth also plays a key role in maintaining the security and decentralization of the Ethereum network.

Can I run a Geth node on a cloud server?

Yes, it’s possible to run a Geth node on a cloud server. However, it’s important to ensure that the server meets the necessary system requirements and has a high-speed internet connection. Running a Geth node on a cloud server can be a cost-effective way to participate in the Ethereum network without needing to maintain your own hardware.

How can I secure my Geth node?

Securing your Geth node involves several steps, including keeping your system and Geth client up to date, using strong, unique passwords for your accounts, and limiting the number of open ports on your system. It’s also recommended to regularly backup your node’s data to prevent loss in case of a system failure.

What is the difference between fast sync and full sync in Geth?

Fast sync and full sync are two different modes for syncing the Ethereum blockchain in Geth. Fast sync downloads the blockchain data much faster by skipping some of the older transaction data, while full sync downloads the entire blockchain data including all transactions. Full sync takes longer but provides a more complete history of the Ethereum network.

How can I troubleshoot issues with my Geth node?

Troubleshooting issues with your Geth node can involve checking the node’s logs for error messages, ensuring that your system meets the necessary requirements, and verifying that your internet connection is stable. If you’re still having trouble, you can seek help from the Geth community on various online forums and discussion boards.

Mislav JavorMislav Javor
View Author

Mislav Javor is a software engineer and CEO (in that order). He writes smart contracts, conducts lectures, and blogs at

Share this article
Read Next
Get the freshest news and resources for developers, designers and digital creators in your inbox each week
Loading form