Skip to main content

How to do a Non-Custodial Transaction with QuickNode

Updated on
Dec 11, 2023

7 min read


Private keys are one of the most sensitive pieces of data when it comes to cryptography and the blockchain. However, there has always been debate/confusion about choosing between custodial wallets (where the wallet provider has custody of the user’s private key) and non-custodial wallets (where the wallet user has custody of the private key). This guide will take a deep dive into understanding the difference between custodial and non-custodial wallets and how to make a non-custodial transaction using QuickNode.


  • Node.js installed on your system.
  • Text editor.
  • Terminal aka Command-Line.

What is a non-custodial wallet?

A non-custodial wallet is a blockchain wallet where the wallet owner is in complete control and has custody of the private key. A non-custodial wallet can be made and accessed using two methods. Using the private key (an alphanumeric string) or using a mnemonic seed phrase, a 12-24 word phrase stored on the wallet owner’s end (generally written down and stored in a secure place, off the internet and computer).

Following are some advantages of a non-custodial wallet:

  • Autonomy - users are in complete control of their funds - as the user is the only entity with complete control over their funds. They don’t have to depend on any third party to manage or secure their wallet.
  • Safety -as the users store their private keys off the internet or any computer,  the chances of a security breach are almost negligible.
  • Instant withdrawal - with non-custodial wallets, users don’t have to depend on any third party to confirm their withdrawal request. This streamlines the whole process and allows for instant withdrawals.

Non-custodial wallet vs. custodial wallet

Subscribe to our YouTube channel for more videos!
  • Custodian of Private key - The foremost factor to consider when comparing crypto wallets is possession of the private key. In the case of a non-custodial wallet, the user has custody of the private key. A third party (usually a wallet provider or exchange) controls the private key with custodial wallets.
  • Transaction Type - The transactions made by non-custodial wallets are visible instantly on-chain. In contrast, the transaction made by custodial wallets has to go through various checks by the third party and are prone to latency.
  • Security - In non-custodial wallets, the user has the private key stored locally. The wallet is very secure unless the user shares the private key or the device gets stolen. In custodial wallets, all the sensitive user data like private keys are stored on hot data storage (updated instantly) and cold data storage (updated from time to time), usually prone to hacking.
  • Offline Accessibility - Non-custodial wallets don’t need an internet connection actively. Custodial wallets need an internet connection as the data is usually stored on a centralized server.
  • Backup and Recovery - The only drawback with non-custodial wallets is that once the private key/mnemonic seed is lost, there is no way to recover the wallet. In contrast, custodial wallet users can request a third party for recovery.

Using a non-custodial node

At QuickNode, we run many nodes globally. All of these nodes are constantly connected to the internet and are dynamic. The QuickNode API is connected to a global network of powerful nodes. These nodes are not always connected to a single infrastructure component. The API is designed to perform dynamic switches between single infrastructure components to facilitate better stability and uptime. This makes storing any sensitive data on a node less than ideal as they are constantly in flux. There is also a security aspect to this as these nodes are facing the internet. We don’t allow them to store private keys for the security of our user’s data.  Because they are dynamic, they change their state often to provide better performance. This means the keys can be lost, resulting in the user’s data being lost. These were the reasons for running non-custodial nodes and having our users be the sole controller of their wallets. In the coming sections, we’ll see how to create a wallet using a library, make a non-custodial transaction, and send it using QuickNode.

Set Up Your QuickNode Ethereum Endpoint

We could use pretty much any Ethereum client, such as Geth or OpenEthereum (fka Parity), for our purposes today. Since that is a bit too involved for sending transactions, we'll just create a free QuickNode account here and easily generate an Ethereum endpoint. We’ll use the Kovan Test Chain to make the transfers. After you've created your free Ethereum endpoint, copy your HTTP Provider URL:

A screenshot of the Quicknode Ethereum endpoint Getting Started page with an HTTP link and WSS

You'll need this later, so copy and save it.

Creating a wallet and getting some test ETH

We could use any of the many available web3 libraries to create a wallet. Today we’ll use ethers.js, a javascript library, to create a wallet that will sign and send transactions. You can also refer to our guides on creating an Ethereum wallet in Go / Python / RubyPHP.

We’ll install ethers using npm (Node Package Manager), which comes with node.js. Open your cmd/terminal and type the following to check if node.js is installed or not:

node -v 

This should return the installed version of node.js; if not installed, download the LTS version of node.js from its official website.

Let’s create a new directory for our project, and make that directory as our current working directory in the cmd/terminal:

mkdir noncusTransaction
cd noncusTransaction

Now install ethers by typing the following:

npm i ethers@5.7

Make sure you are installing Ethers.js version 5.7

The most common issue at this step is an internal failure with `node-gyp`. You can follow node-gyp installation instructions here.

Note: You will need to have your python version match one of the compatible versions listed in the instructions above if you encounter the node-gyp issue. 

Another common issue is a stale cache; clear your npm cache by simply typing the below into your cmd/terminal:

npm cache clean

If everything goes right, ethers.js will be installed on your system.

Now, open a text editor and create a new javascript file called transaction.js. Copy-paste the following into the file.

var ethers = require('ethers');  
var privateKey = "0x0111111111111111111122222222222222222223333333333333333333344445";
var wallet = new ethers.Wallet(privateKey);
console.log("Address: " + wallet.address);

Explanation of the code above:

Line 1: Importing the ethers library.

Line 2: Storing a private key in variable privateKey, make sure to get your own private key. You can learn how to generate one by following this guide on generating a private key using JavaScript.

Note: If you were to put your code on the internet, (such as a public github repo) then It’s always a good practice to store the private key in a .env file and import it in your main code through an environment variable. 

Line 3: Creating a new wallet address using the private key and storing it in the variable wallet.

Line 4: Printing the wallet address along with a string.

Now, save the file and run the script.

node transaction

It should look like this.

Now, let’s get some test ETH to send during the transaction and to pay the gas fee. Copy the address from the output, go to Kovan faucet login with GitHub or GitLab, paste the wallet address into the text field in the faucet, then click "Send me KETH!".

You can check if you received the test ETH or not by pasting the address into the Kovan Etherscan, and you will see the ETH balance.

Sending a non-custodial transaction

Let us create a token transfer transaction using the wallet we created earlier and send the transaction to the chain using QuickNode.

Update your transaction.js as following:

var ethers = require('ethers');  
var customHttpProvider = new ethers.providers.JsonRpcProvider(url);
var privateKey = "0x0111111111111111111122222222222222222223333333333333333333344445";
var wallet = new ethers.Wallet(privateKey);
console.log("Address: " + wallet.address);
tx = {
to: "0x6E0d01A76C3Cf4288372a29124A26D4353EE51BE",
value: ethers.utils.parseEther("0.05"),
chainId: 42,
nonce: 11
customHttpProvider.estimateGas(tx).then(function(estimate) {
tx.gasLimit = estimate;
tx.gasPrice = ethers.utils.parseUnits("3.14085197", "gwei");

So go ahead and replace `ADD_YOUR_ETHEREUM_NODE_URL` with the HTTP provider from the section above.

Explanation of the code above.

Line 1: Importing ethers library.

Line 2: Storing our QuickNode URL in the url variable.

Line 3: Instantiating new ethers provider and storing in variable customHttpProvider.

Line 4: Storing private key in privateKey variable (you must generate your private key).

Line 5: Creating a new wallet from the private key.

Line 6: Printing the wallet address along with a string.

Line 7-12: Initializing our transaction object, and supplying parameters like ‘to’, which has the receiver's address (any address to which the transaction is to be sent). Secondly, ‘value’ which has the value of ETH to be transferred. Thirdly, ‘chainId’ is the network id of the chain (42 here because we are using Kovan testnet). Last of all, ‘nonce’ which is the count of transactions a sender has sent. The value here should always be the number of previous transactions +1.

 We can also obtain the nonce for a given address using the getTransactionCount() method of ethers.js.

Line 13-14: Estimating gas using the provider, then storing it in the gasLimit variable of the transaction object.

Line 15: Setting gas price and storing it in gasPrice variable of transaction.

Line 16: Signing the transaction using the wallet.

Line 17: Sending the signed transaction using the provider and printing the transaction details to the console.

Save the file and run it using:

node transaction

It will give an output similar to this:

Copy the transaction hash and paste it into the search bar of Kovan Etherscan to check if it got confirmed or not.


Congratulations on making a non-custodial transaction and being the sole controller of your funds. Never share your private key with anyone; always store it in a safe place for the better safety of your wallet and funds.

Subscribe to our newsletter for more articles and guides on Ethereum. You can also always reach us on Twitter and Discord community server, featuring some of the coolest developers you’ll ever meet :)

We ❤️ Feedback!

Let us know if you have any feedback or requests for new topics. We'd love to hear from you.

Share this guide