How To Programmatically Generate NFT

Are you tired of watching those tedious promo videos and want the code now? Nft can be generated programmatically. Here are the steps to do it.

Writing to the Blockchain

Writing to the blockchain is not a trivial task. It requires an understanding of the underlying technology and a familiarity with how to effectively use it. In this article, we will attempt to explain the process of writing to the blockchain in a simple and intuitive manner for those who are new to the concept.

The first step in understanding how to write to the blockchain is learning about distributed ledgers, which are essentially a way of recording transactions on multiple computers at once. These ledgers are often referred to as blockchains, which is why they are often confused with cryptocurrencies like Bitcoin.

To understand what it means when someone writes data to a blockchain, we need to look at how data is stored in regular databases. A database stores information using tables made up of rows and columns (similar to spreadsheets). Each row represents one record and each column represents one field or attribute in that record.

For example: If you wanted to store information about your family members in a table, you might have columns for name, age and address. If you wanted to store information about your favorite sports teams, you might have columns for team name and city location (among other things). The important thing here is that each record has its own unique identifier.

Using The Nft Registry

The Nft Registry is a tool that allows you to programmatically generate NFTs. It is powered by ERC-721 and ERC-1155.

Nft Registry makes it easy to create and publish new crypto assets. The tool can also be used to create new extensions on your pre-existing crypto assets.

The NFT Registry provides two key features:

  • Automated creation of new items using a JSON file that contains only the necessary information for creating an item (name, image, description, etc.).
  • Encryption of any asset that is associated with an ERC-721 or ERC-1155 token.

Simple Code to Generate Nfts

NFTs can be generated in a very simple way using the API. The code below generates an NFT, and matches the output to the public key of the user who owns it:

  • constcreateNft = async () => {
  • //Get the current time in milliseconds
  • const now = new Date().getTime();
  • //Create a random string between 8 and 16 characters long
  • constnumChars = 16;
  • constrandNum = Math.floor(Math.random() * numChars) + ‘a’;
  • //Create an ERC721 token with that name, set it as owned by this user, and add it to their inventory
  • await blockchain.createToken({name: randNum, symbol: ‘NFT’, decimals: 0});
  • // This line is needed because otherwise we won’t see our tokens in our account or on Etherscan

Creating the NFT class

The NFT class is the base class for all NFTs. It defines the basic functions that any NFT needs to have: getter and setter functions, a constructor, a destructor, and the ability to check whether an NFT is valid for use.

The following code creates an NFT class named MyNFT. It inherits from the NFT class, then defines some basic functions. The getters and setters are simple: they return a string containing the name of the token as it appears in your wallet. The constructor takes three arguments:

  • a string representing the name of the token
  • the numeric value of that token’s owner ownerID field (e.g., 1)
  • the numeric value of that token’s issuer issuerID field (e.g., 2).

Generate NFT instances

NFTs are ERC721 tokens, and as such we can use the same methods we’ve been using to generate ERC20 tokens in our projects. The two most common ways to do this are via ganache-cli or by creating our own test network.

How To Programmatically Generate Nft

A common use case I have is to generate a NFT. This can be done programmatically using the following steps:

  • Create a new file called nft-generator.js .
  • Add the following code to nft-generator.js :
  • varnftGenerator = {};
  • nftGenerator.generate = function(type, value) {
  • console.log(‘generating %s %d’, type, value);
  • return {
  • type: type,
  • value: value


We can create a simple script that we can call to deploy our script to the network of our choice. Polygon’s Mumbai testnet. For this, we also need to add some small options in the Hardhat config.

Inside the scripts folder, create a new file called deploy-script.js and add the following code to it.

The private key should be the private key from your MetaMask wallet. We now have everything we should need to deploy a contract if you have testnet MATIC tokens in your wallet from which the private key is by running.