Tutorial: Writing an NFT Collectible Smart Contract (2023)

Tutorial: Writing an NFT Collectible Smart Contract (1)

In our previous tutorials, we showed you how to use our generative art library to create a collection of avatars, generate compliant NFT metadata, and upload the metadata JSON and media files to IPFS.

However, we haven’t minted any of our avatars as NFTs yet. Therefore, in this tutorial, we will write a smart contract that will allow anyone to mint an NFT from our collection by paying gas and a price that we’ve set for each NFT piece.

Tutorial: Writing an NFT Collectible Smart Contract (2)
  1. Intermediate knowledge of JavaScript.
    (In case you need a refresher, I’d suggest this YouTube tutorial)
  2. Intermediate knowledge of Solidity and OpenZeppelin Contracts
    (We will be releasing tutorials on this very soon! For the time being, we strongly recommend CryptoZombies and Buildspace)
  3. NodeJS and npm installed on your local computer
    (You can download the latest version here)
  4. A collection of media files and NFT metadata JSON uploaded to IPFS.
    (In case you don’t have this, we have created a toy collection for you to experiment with. You can find the media files here and the JSON metadata files here).

While it may be possible for readers who do not satisfy the prerequisites to follow along and even deploy a smart contract, we strongly recommend getting a developer who knows what s/he is doing if you’re serious about your project. Smart contract development and deployment can be incredibly expensive and unforgiving wrt security flaws and bugs.

Tutorial: Writing an NFT Collectible Smart Contract (3)

We will be using Hardhat, an industry-standard ethereum development environment, to develop, deploy, and verify our smart contracts. Create an empty folder for our project and initialize an empty package.json file by running the following command in your Terminal:

mkdir nft-collectible && cd nft-collectible && npm init -y

You should now be inside the nft-collectible folder and have a file named package.json .

Next, let’s install Hardhat. Run the following command:

npm install --save-dev hardhat

We can now create a sample Hardhat project by running the following command and choosing Create a basic sample project.

npx hardhat
Tutorial: Writing an NFT Collectible Smart Contract (4)

Agree to all the defaults (project root, adding a .gitignore, and installing all sample project dependencies).

Let’s check that our sample project has been installed properly. Run the following command:

npx hardhat run scripts/sample-script.js

If all goes well, you should see output that looks something like this:

Tutorial: Writing an NFT Collectible Smart Contract (5)

We now have our hardhat development environment successfully configured. Let us now install the OpenZeppelin contracts package. This will give us access to the ERC721 contracts (the standard for NFTs) as well as a few helper libraries that we will encounter later.

npm install @openzeppelin/contracts

If we want to share our project’s code publicly (on a website like GitHub), we wouldn’t want to share sensitive information like our private key, our Etherscan API key, or our Alchemy URL (don’t worry if some of these words don’t make sense to you yet). Therefore, let us install another library called dotenv.

npm install dotenv

Congratulations! We are now in a good place to start developing our smart contract.

(Video) How to Write a Basic NFT Contract from Scratch | Solidity, Remix

Tutorial: Writing an NFT Collectible Smart Contract (6)

In this section, we are going to write a smart contract in Solidity that allows anyone to mint a certain number of NFTs by paying the required amount of ether + gas.

In the contracts folder of your project, create a new file called NFTCollectible.sol.

We will be using Solidity v8.0. Our contract will inherit from OpenZeppelin’s ERC721Enumerable and Ownable contracts. The former has a default implementation of the ERC721 (NFT) standard in addition to a few helper functions that are useful when dealing with NFT collections. The latter allows us to add administrative privileges to certain aspects of our contract.

In addition to the above, we will also use OpenZeppelin’s SafeMath and Counters libraries to safely deal with unsigned integer arithmetic (by preventing overflows) and token IDs respectively.

This is what the skeleton of our contract looks like:

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract NFTCollectible is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;

Counters.Counter private _tokenIds;

Storage constants and variables

Our contract needs to keep track of certain variables and constants. For this tutorial, we will be defining the following:

  1. Supply: The maximum number of NFTs that can be minted in your collection.
  2. Price: The amount of ether required to buy 1 NFT.
  3. Maximum number of mints per transaction: The upper limit of NFTs that you can mint at once.
  4. Base Token URI: The IPFS URL of the folder containing the JSON metadata.

In this tutorial, we will set 1–3 as constants. In other words, we won’t be able to modify them once the contract has been deployed. We will write a setter function for baseTokenURI that will allow the contract’s owner (or deployer) to change the base URI as and when required.

Right under the _tokenIds declaration, add the following:

uint public constant MAX_SUPPLY = 100;
uint public constant PRICE = 0.01 ether;
uint public constant MAX_PER_MINT = 5;

string public baseTokenURI;

Notice that I’ve used all caps for the constants. Feel free to change the values for the constants based on your project.


We will set the baseTokenURI in our constructor call. We will also call the parent constructor and set the name and symbol for our NFT collection.

Our constructor, therefore, looks like this:

constructor(string memory baseURI) ERC721("NFT Collectible", "NFTC") {

Reserve NFTs function

As the creator of the project, you probably want to reserve a few NFTs of the collection for yourself, your team, and for events like giveaways.

Let’s write a function that allows us to mint a certain number of NFTs (in this case, ten) for free. Since anyone calling this function only has to pay gas, we will obviously mark it as onlyOwner so that only the owner of the contract will be able to call it.

function reserveNFTs() public onlyOwner {
uint totalMinted = _tokenIds.current();
totalMinted.add(10) < MAX_SUPPLY, "Not enough NFTs"
for (uint i = 0; i < 10; i++) {

We check the total number of NFTs minted so far by calling tokenIds.current(). We then check if there are enough NFTs left in the collection for us to reserve. If yes, we proceed to mint 10 NFTs by calling _mintSingleNFT ten times.

It is in the _mintSingleNFT function that the real magic happens. We will look into this a little later.

Setting Base Token URI

Our NFT JSON metadata is available at this IPFS URL: ipfs://QmZbWNKJPAjxXuNFSEaksCJVd1M6DaKQViJBYPK2BdpDEP/

When we set this as the base URI, OpenZeppelin’s implementation automatically deduces the URI for each token. It assumes that token 1’s metadata will be available at ipfs://QmZbWNKJPAjxXuNFSEaksCJVd1M6DaKQViJBYPK2BdpDEP/1, token 2’s metadata will be available at ipfs://QmZbWNKJPAjxXuNFSEaksCJVd1M6DaKQViJBYPK2BdpDEP/2 , and so on.

(Please note that there is no .json extension to these files)

However, we need to tell our contract that the baseTokenURI variable that we defined is the base URI that the contract must use. To do this, we override an empty function called _baseURI() and make it return baseTokenURI.

(Video) Write an ERC-721 NFT token from SCRATCH - Solidity Smart Contract Tutorial!

We also write an only owner function that allows us to change the baseTokenURI even after the contract has been deployed.

function _baseURI() internal 
returns (string memory) {
return baseTokenURI;

function setBaseURI(string memory _baseTokenURI) public onlyOwner {
baseTokenURI = _baseTokenURI;

Mint NFTs function

Let us now turn our attention to the main mint NFTs function. Our users and customers will call this function when they want to purchase and mint NFTs from our collection.

Since they’re sending ether to this function, we have to mark it as payable.

We need to make three checks before we allow the mint to take place:

  1. There are enough NFTs left in the collection for the caller to mint the requested amount.
  2. The caller has requested to mint more than 0 and less than the maximum number of NFTs allowed per transaction.
  3. The caller has sent enough ether to mint the requested number of NFTs.
function mintNFTs(uint _count) public payable {
uint totalMinted = _tokenIds.current();
totalMinted.add(_count) <= MAX_SUPPLY, "Not enough NFTs!"
_count > 0 && _count <= MAX_PER_MINT,
"Cannot mint specified number of NFTs."
msg.value >= PRICE.mul(_count),
"Not enough ether to purchase NFTs."
for (uint i = 0; i < _count; i++) {

Mint Single NFT function

Let’s finally take a look at the private _mintSingleNFT() function that’s being called whenever we (or a third party) want to mint an NFT.

function _mintSingleNFT() private {
uint newTokenID = _tokenIds.current();
_safeMint(msg.sender, newTokenID);

This is what is happening:

  1. We get the current ID that hasn’t been minted yet.
  2. We use the _safeMint() function already defined by OpenZeppelin to assign the NFT ID to the account that called the function.
  3. We increment the token IDs counter by 1.

The token ID is 0 before any mint has taken place.

When this function is called for the first time, newTokenID is 0. Calling safeMint() assigns NFT with ID 0 to the person who called the contract function. The counter is then incremented to 1.

The next time this function is called, _newTokenID has value 1. Calling safeMint() assigns NFT with ID 1 to the person who… I think you get the gist.

Note that we don’t need to explicitly set the metadata for each NFT. Setting the base URI ensures that each NFT gets the correct metadata (stored in IPFS) assigned automatically.

Getting all tokens owned by a particular account

If you plan on giving any sort of utility to your NFT holders, you would want to know which NFTs from your collection each user holds.

Let’s write a simple function that returns all IDs owned by a particular holder. This is made super simple by ERC721Enumerable ‘s balanceOf and tokenOfOwnerByIndex functions. The former tells us how many tokens a particular owner holds, and the latter can be used to get all the IDs that an owner owns.

function tokensOfOwner(address _owner) 
returns (uint[] memory) {
uint tokenCount = balanceOf(_owner);
uint[] memory tokensId = new uint256[](tokenCount);
for (uint i = 0; i < tokenCount; i++) {
tokensId[i] = tokenOfOwnerByIndex(_owner, i);

return tokensId;

Withdraw balance function

All the effort we’ve put in so far would go to waste if we are not able to withdraw the ether that has been sent to the contract.

Let us write a function that allows us to withdraw the contract’s entire balance. This will obviously be marked as onlyOwner.

function withdraw() public payable onlyOwner {
uint balance = address(this).balance;
require(balance > 0, "No ether left to withdraw");
(bool success, ) = (msg.sender).call{value: balance}("");
require(success, "Transfer failed.");

Final Contract

We’re done with the smart contract. This is what it looks like. (By the way, if you haven’t already, delete the Greeter.sol file.)

Let us now make preparations to deploy our contract to the Rinkeby test network by simulating it in a local environment.

In the scripts folder, create a new file called run.js and add the following code:

This is some Javascript code that utilizes the ethers.js library to deploy our contract, and then call functions of the contract once it has been deployed.

Here is the series of what’s going on:

  1. We get the address of the deployer/owner (us)
  2. We get the contract that we want to deploy.
  3. We send a request for the contract to be deployed and wait for a miner to pick this request and add it to the blockchain.
  4. Once mined, we get the contract address.
  5. We then call public functions of our contract. We reserve 10 NFTs, mint 3 NFTs by sending 0.03 ETH to the contract, and check the NFTs owned by us. Note that the first two calls require gas (because they’re writing to the blockchain) whereas the third simply reads from the blockchain.

Let’s give this a run locally.

(Video) NFT/ERC-721/Collectible TUTORIAL | Deploy, List on Opensea, Host Metadata on IPFS [See Description]

npx hardhat run scripts/run.js

If all goes well, you should see something like this:

Tutorial: Writing an NFT Collectible Smart Contract (7)

To deploy our contract to Rinkeby, we will need to set up a few things.

First, we will need an RPC URL that will allow us to broadcast our contract creation transaction. We will use Alchemy for this. Create an Alchemy account here and then proceed to create a free app.

Tutorial: Writing an NFT Collectible Smart Contract (8)

Make sure that the network is set to Rinkeby.

Once you’ve created an app, go to your Alchemy dashboard and select your app. This will open a new window with a View Key button on the top right. Click on that and select the HTTP URL.

Acquire some fake Rinkeby ETH from the faucet here. For our use case, 0.5 ETH should be more than enough. Once you’ve acquired this ETH, open your Metamask extension and get the private key for the wallet containing the fake ETH (you can do this by going into Account Details in the 3-dots menu near the top-right).

Do not share your URL and private key publicly.

We will use the dotenv library to store the aforementioned variables as environment variables and will not commit them to our repository.

Create a new file called .env and store your URL and private key in the following format:


Now, replace your hardhat.config.js file with the following contents.

We’re almost there! Run the following command:

npx hardhat run scripts/run.js --network rinkeby

This should give you output very similar to what you got earlier, except that this has been deployed to the real blockchain.

Make a note of the contract address. Ours was 0x355638a4eCcb777794257f22f50c289d4189F245.

You can check this contract out on Etherscan. Go to Etherscan and type in the contract address. You should see something like this.

Tutorial: Writing an NFT Collectible Smart Contract (9)

Believe it or not, our NFT collection is now already available on OpenSea without us having to upload it explicitly. Go to testnets.opensea.io and search for your contract address.

This is what our collection looks like:

Tutorial: Writing an NFT Collectible Smart Contract (10)
(Video) How to create an NFT Smart Contract (ERC721)

We have come a LONG way in this article but there is one final thing we’d like to do before we go.

Let’s verify our contract on etherscan. This will allow your users to see your contract’s code and ensure that there is no funny business going on. More importantly, verifying your code will allow your users to connect their Metamask wallet to etherscan and mint your NFTs from etherscan itself!

Before we can do this, we will need an Etherscan API key. Sign up for a free account here and access your API keys here.

Let’s add this API key to our .env file.


Hardhat makes it really simple to verify our contract on Etherscan. Let’s install the following package:

npm install @nomiclabs/hardhat-etherscan

Next, make adjustments to hardhat.config.js so it looks like this:

Now, run the following two commands:

npx hardhat cleannpx hardhat verify --network rinkeby DEPLOYED_CONTRACT_ADDRESS "BASE_TOKEN_URI"

In our case, the second command looked like this:

npx hardhat verify --network rinkeby 0x355638a4eCcb777794257f22f50c289d4189F245 "ipfs://QmZbWNKJPAjxXuNFSEaksCJVd1M6DaKQViJBYPK2BdpDEP/"
Tutorial: Writing an NFT Collectible Smart Contract (11)

Now, if you visit your contract’s Rinkeby Etherscan page, you should see a small green tick next to the Contract tab. More importantly, your users will now be able to connect to web3 using Metamask and call your contract’s functions from Etherscan itself!

Tutorial: Writing an NFT Collectible Smart Contract (12)

Try this out yourself.

Connect the account that you used to deploy the contract and call the withdraw function from etherscan. You should be able to transfer the 0.03 ETH in the contract to your wallet. Also, ask one of your friends to connect their wallet and mint a few NFTs by calling the mintNFTs function.

We now have a deployed smart contract that lets users mint NFTs from our collection. An obvious next step would be to build a web3 app that allows our users to mint NFTs directly from our website. This will be the subject of a future tutorial.

If you’ve reached this far, congratulations! You are on your way to becoming a master Solidity and blockchain developer. We’ve covered some complex concepts in this article and coming this far is truly incredible. We’re proud. :)

We would love to take a look at your collection. Come say hi to us on our Discord. Also, if you liked our content, we would be super grateful if you tweet about us, follow us(@ScrappyNFTs and @Rounak_Banik), and invite your circle to our Discord. Thank you for your support!

Final code repository: https://github.com/rounakbanik/nft-collectible-contract

About Scrappy Squirrels

Scrappy Squirrels is a collection of 10,000+ randomly generated NFTs. Scrappy Squirrels are meant for buyers, creators, and developers who are completely new to the NFT ecosystem.

(Video) Polygon NFT Tutorial 8 - Writing Smart Contract

The community is built around learning about the NFT revolution, exploring its current use cases, discovering new applications, and finding members to collaborate on exciting projects with.

Join our community here: https://discord.gg/8UqJXTX7Kd


How do I create a smart contract for my NFT collection? ›

Get Your Environment Set Up
  1. Install the CLI tool. This one liner will install the tool so you can start using it right away. ...
  2. Set the network. We're going to use GoChain here so we don't have to pay $100 to deploy the contract then then $50 to mint every NFT. ...
  3. Add / Get Gas. ...
  4. Creating the Contract. ...
  5. Deploy the Contract.
Mar 9, 2021

Do I need a smart contract for my NFT collection? ›

A smart contract is the foundation of all NFT collections. Think of it as the key that can unlock a specific door. In this case, this key is what can verify the authenticity of an NFT, or rather, your entire collection.

How do people make 10,000 NFT collections? ›

  1. Step 1: Create Layers in Photoshop. The first step in creating an NFT collection is to create the different layers that make up the NFT. ...
  2. Step 2: Generate NFTs and Metadata Files with Rarity. ...
  3. Step 3: Upload NFTs to the IPFS. ...
  4. Step 4: Create a Smart Contract and Mint the First NFT. ...
  5. Step 5: Sell NFTs on an NFT Marketplace.
Jan 25, 2023

How an NFT creator lost $34 million due to a smart contract error? ›

The much-anticipated NFT launch of the Aku Dreams collection was abruptly halted due to some apparent flaws in the project's code. The launch hit a snag after a bug in the smart contract caused $34 million worth of Ether tokens to be locked forever.

How do I create and sell an entire NFT collection? ›

  1. How to make and sell an NFT. ...
  2. Choose a digital wallet. ...
  3. Set up a digital wallet to pay for your NFT. ...
  4. Add cryptocurrency to your wallet. ...
  5. Connect your wallet to an NFT platform. ...
  6. Upload the file you want to turn into an NFT. ...
  7. Set up an auction for your NFT. ...
  8. Add a description to sell your NFT.
Nov 15, 2022

How do you make a smart contract from scratch? ›

How to create a smart contract
  1. Step 1: Connect to the Ethereum network. ...
  2. Step 2: Choose a test network. ...
  3. Step 3: Fund your wallet with Testnet ETH. ...
  4. Step 4: Use the Remix browser to write your smart contract. ...
  5. Step 5: Create a . ...
  6. Step 6: Complete your smart contract code. ...
  7. Step 7: Deploy the smart contract.
Jun 15, 2022

How much does it cost to create an NFT smart contract? ›

Typically, the cost to create an NFT will range from $1-$500. However, in some cases the cost to create an NFT could be over $1000. Looking for inexpensive blockchain solutions that support lazy minting or gasless minting will help your organization control costs.

How much does it cost to launch an NFT smart contract? ›

Your smart contract will include the coding required to allow the minting of your NFT collection on the blockchain of your choice. This is a crucial component of NFT creation, and the average cost of a smart contract begins at $500.

What does an NFT smart contract look like? ›

An NFT smart contract is blockchain computer programming that manages and enhances digital assets, or non-fungible tokens. An NFT can be owned by only one person at a time. A smart contract can activate and deactivate an NFT. An NFT can be used to represent ownership of real-world objects.

How many traits for a 5000 NFT collection? ›

When creating traits for your NFTs, you want to make sure that you have at least 150 traits. The more traits you have, the more diverse your project will be. However, if you make too many traits, a project can quickly become overwhelming.

How many traits for a 10k NFT collection? ›

Think around 200 or so overall traits for a decent set.

It's usually more like 15 or so properties with 20+ traits within each one -- or much more.

How many layers for a 10k NFT collection? ›

To make 10,000 NFTs, you need 10 layers with 4 variations each. Of course, it will be very difficult to combine 10,000 images manually. Therefore, you will need NFT-Generator to do so.

How much does it cost to create 10,000 NFT collection? ›

The cost to mint one NFT can range from about $1 to over $1,000. The cost of minting 10 000 NFTs could be as low as $5000 to as high as $1 million, depending on the blockchain. The costs to mint a single NFT can vary from $1 to over $1,000, so it's important to understand how much a particular blockchain costs.

Why most NFT projects fail? ›

Summary. It is no easy task to head an NFT project, and in most cases, it is an uphill battle to stand out and survive past launch. NFT projects fail due to a lack of planning, bad decision making, an unprofessional team, and a lack of passion, all can crash an otherwise promising NFT project.

What is a good percentage of creator fee from NFT? ›

Usually, these percentages are between 5-10% of the price, and this figure is often applied to secondary sales of the NFT. Royalties are trackable on the blockchain since the royalties' specifications are coded into the creator's smart contract.

How much does the average NFT collection make? ›

The analysis revealed that over the last 30 days, the average price for NFT art is $232.24 per artwork. Average 30-day sales for an NFT collection total $42,499.92, based on the average NFT price and average sales volume of 183 sales per month.

How many items should an NFT collection have? ›

Unwritten guidelines state that a project should contain 4,000– 10,000 NFTs. This varies widely,though,as some collections only have 50 or 250 NFTs. Of course,there is one-of-a-kind digital art on the other end of the range.

How much does the average NFT collection sell? ›

How much do NFTs sell for? The average price of an NFT can vary anywhere from $100 to $1,400, depending on its scarcity, utility, and popularity. Additionally, fluctuations in the value of the underlying cryptocurrency may impact a non-fungible token's price.

Are smart contracts hard to write? ›

It isn't technically more challenging that most coding languages. To develop basic smart contracts, or decentralized applications (dApps), doesn't required you to have a background in cryptography, game theory, protocol design, distributed computer networks, or anything of the like.

What is a simple example of smart contract? ›

Examples of smart contract applications include financial purposes like trading, investing, lending, and borrowing. They can be used for applications in gaming, healthcare, and real estate; and they can even be used to configure entire corporate structures.

How much money can I make with smart contracts? ›

Smart Contract Developer Salary - Apr 2023
PositionAvg Yearly SalaryMax Yearly Salary
Python Developer$97k$200k
AI Engineer$95k$180k
QA Engineer$95k$180k
Junior Developer$75k$180k
31 more rows

Can a smart contract be owner of NFT? ›

How do NFT smart contracts work? NFTs are minted via smart contracts that also assign and reassign ownership. Smart contracts for NFTs reassign ownership when an NFT is being sold, transferring it from the previous owner to the new buyer.

How much money do you need to start an NFT project? ›

On average, the cost of creating NFT ranges from $0.05 to over $150. The cost of creating NFTs depends on various factors such as the cost of blockchain, gas fee, marketplace account fee, listing fee etc.

How much do you need to launch an NFT project? ›

The cost of minting an NFT often varies depending on gas and site fees. On the Ethereum blockchain, for instance, you can expect to pay around $70 to secure the token. Site fees average around $300, though some sites allow you to list NFTs for free.

How much does it cost roughly to launch a whole NFT collection? ›

Estimated cost - $0.01 - $2.00 per NFT minted + gas fee

These elements will have profound effects on the cost to mint the collection. You can reduce these costs by using features like Lazy Minting, but all that does is push the cost to later in the pipeline when each NFT is sold.

How much does a NFT developer cost? ›

In order to process NFT payments using cryptocurrencies, the NFT marketplace needs a reliable and secure method of integrating crypto wallets. NFT marketplace development cost with respect to payment options ranges from $2385 – $5040.

What is the difference between NFT contract and collection? ›

The NFT Collection contract is suitable for when you want to have a collection of unique NFTs, but not "drop" or "release" them for your community to claim. Unlike the NFT Drop contract, the NFT Collection contract does not lazy mint your NFTs. Instead, NFTs are minted immediately when they are added to the collection.

Does OpenSea Create smart contracts? ›

To deploy a contract for the first time, connect your wallet to OpenSea and navigate to your “My Collections” page. Click Create a collection. For a Drop, you'll need to deploy your own custom smart contract, which you can do directly using the OpenSea interface.

What is the difference between token and smart contract? ›

A token contract is simply an Ethereum smart contract. "Sending tokens" actually means "calling a method on a smart contract that someone wrote and deployed". At the end of the day, a token contract is not much more a mapping of addresses to balances, plus some methods to add and subtract from those balances.

What is the rarest NFT trait? ›

The rarest trait method is pretty simple – it assigns a rarity rank to an NFT based on its rarest trait. The rarer that leading trait is, the higher the overall rarity rank. At first sight, it seems logical to base the rarity on an NFT's champion trait.

What is considered rare in an NFT collection? ›

An NFT's rarity plays a role in its perceived cultural and artistic significance. For example, an nonfungible token (NFT) that is the only one of its kind and possesses significant cultural or historical value may be considered a rare and must-have artifact.

What is a typical NFT royalty percentage? ›

When an NFT is minted, the creator has the option to set a royalty percentage that they will receive whenever their NFT is sold in the future. The percentage typically ranges from 2.5% to 10%, but it can be customized to the creator's liking.

What is the formula for NFT collection? ›

Number of NFTs = (Number of traits) ^ (Number of layers)

Using this formula you can also figure out how many traits each layer needs to have to generate a certain number of NFTs.

What is a good NFT collection size? ›

Usually, the dimensions for a pixel NFT image are 32 × 32px because the art just feels natural at this size. Also, it's the most commonly used pixel art size. However, NFT artists also create pixel art in other dimensions including 64 × 64px, 32 × 32px, 24 × 24px, 20 × 20px, and 16 × 16px.

How many editions of NFT should I make? ›

Most platforms allow you to create an unlimited number of NFTs. However, you should think through how many editions of the same NFT you want to issue: 1-of-1. You only issue one copy of the NFT, which makes it more valuable.

How much does it cost to mint a 1000 NFT collection? ›

The cost to mint an NFT will vary depending on the marketplace you use and the blockchain you mint on. To mint on Ethereum, the most popular blockchain for NFTs, you'll usually have to pay gas fees, which can get costly. Along with listing fees and commissions, your costs could range anywhere from $0.01 to $1000.

How to mint 10,000 NFTs at once? ›

To do so, click on the ”Deploy” tab just below ”Solidity Compiler”. Then, select ”Injected Web3”, the right contract, and click on ”Deploy”. Once deployed, you'll receive a contract address that you can utilize to view the NFTs on the testnet version of OpenSea. That's it for this tutorial on how to mint 10,000 NFTs!

What is lazy minting? ›

Lazy minting NFTs are created using smart contracts on a blockchain network. These smart contracts are programmed to only mint an NFT when it is sold, allowing creators to create and sell NFTs without the upfront costs and technical requirements of traditional NFT creation.

What coding language should I learn for NFT? ›

1. What language are NFTs coded in? The solidity programming language used to create smart contracts is a high-level language similar to Java and Python and is appropriate for Ethereum, which hosts most NFTs. Many utility-focused NFTs with real-world applications are created using this.

Can you make money creating an NFT collection? ›

Royalties: As an artist or creator of an NFT, you can get royalties for each sale of your work. Just make sure to specify this when you mint your NFT. Staking: If you own valuable NFTs and store them long-term on a platform or in a protocol (known as “staking”), you can earn interest on them.

What is the negative side of NFT? ›

The storage methods used to house NFTs based on blockchain technology are responsible for emitting millions of tons of carbon dioxide, which is harmful to an already overheated planet.

What is the biggest problem of NFT? ›

The main challenge faced in the NFT market is the uncertainty in determining the price of the NFT. Now, the price of any NFT will depend on the creativity, uniqueness, scarcity of the buyers and owners, and a lot more.

What makes a strong NFT project? ›

One of the most important parts of building a successful NFT project is setting your initial NFT mint price correctly. If you charge too high of a mint price upfront, you risk losing your momentum, not selling out your collection, and losing the support of your collectors.

Can you list an NFT below floor price? ›

You can only lower fixed-price listings on ERC-721 NFTs, not ERC-1155s. Enter the new price in the Set new price section and click Continue. You'll need to review and confirm the listing in your wallet.

Who is the average NFT purchaser? ›

Data from Statistica shows that among the age group with the largest interest (18 - 34) men and women own NFTs fairly equally, with 24% men and 21% women.

What is a smart contract for an NFT collection? ›

An NFT smart contract is blockchain computer programming that manages and enhances digital assets, or non-fungible tokens. An NFT can be owned by only one person at a time. A smart contract can activate and deactivate an NFT. An NFT can be used to represent ownership of real-world objects.

How much does it cost to Create an NFT smart contract? ›

Typically, the cost to create an NFT will range from $1-$500. However, in some cases the cost to create an NFT could be over $1000. Looking for inexpensive blockchain solutions that support lazy minting or gasless minting will help your organization control costs.

How much does a smart contract for NFT cost? ›

The smart contract blues

Depending on the current gas cost on Ethereum, deploying an ERC-721 smart contract can cost anywhere from $400 to $2,000.

What are the keys to a successful NFT collection? ›

Take into account your vision and ability to deliver value long term. Research the top NFT projects on sites like Nonfungible.com or Dune Analytics. Generally, 0.05 - 0.1 ETH is where most successful NFT projects set their mint price. Set your price to invite many supporters to participate (don't make it too expensive)

What is needed to create an NFT collection? ›

How to create and mint an NFT
  1. Decide what type of NFT you want to create. NFTs are versatile—you have plenty of options for choosing which type you want to create. ...
  2. Choose an NFT marketplace. ...
  3. Set up a crypto wallet. ...
  4. Buy crypto through an exchange. ...
  5. Connect your wallet to the NFT platform and mint.
Nov 27, 2022

What is an example of a smart contract? ›

A smart contract is a self-executing program based on if-then logic. For example, vending machines are a ubiquitous presence in everyday life. It's also a simple model of a smart contract: If someone inserts $2 and then presses B4, then the machine dispenses the package of cookies held in the B4 slot.

How much does the average NFT project make? ›

An NFT artist average hourly rate in the United States as of August 16th, 2022, is $19.91, according to Zip Recruiter.

What is the average NFT creator fee? ›

A creator royalty is typically a 5% to 10% cut of the sale price, paid out to the NFT creator. It's how NFT projects generate ongoing revenue following the initial sale of tokens.

How much does it cost to deploy 10,000 NFTs? ›

The cost to mint one NFT can range from about $1 to over $1,000. The cost of minting 10 000 NFTs could be as low as $5000 to as high as $1 million, depending on the blockchain. The costs to mint a single NFT can vary from $1 to over $1,000, so it's important to understand how much a particular blockchain costs.

How much does it cost to create a 10000 NFT collection? ›

The costs for creating 10,000 NFTs will differ depending on the platform and its blockchain you decide to use. You could pay any amount from $1 up to hundreds or thousands of dollars if you use Ethereum's blockchain. In the past, single transactions on Ethereum had fees of up to $500 .

How much should an artist charge for an NFT? ›

It's perfectly reasonable for artists to start selling NFTs at a couple hundred dollars and see where that takes them. As an emerging artist, it's always better to start lower and then raise your prices rather than starting high and having to lower them. The idea is to build loyalty and create interest.

How long does it take to deploy an NFT contract? ›

It costs about 0.03 ETH ($100 - $200) to deploy a contract and mint an NFT on it. It takes less than 30 minutes to get started from start to finish.


1. Royalties NFT smart contract with Solidity (Tutorial)
2. Build an NFT Solidity Smart Contract | Simple OpenZeppelin ERC721 Tutorial
3. Build a Custom NFT Smart Contract | OpenZeppelin ERC721 Tutorial
4. Write test for NFT smart contract using hardhat (ERC-721)
(Web3 For Devs)
5. How To Write A Good NFT Smart Contract - Part 4 | NFT PhD
6. Build an NFT Minting Smart Contract | 2022 OpenZeppelin Solidity Tutorial


Top Articles
Latest Posts
Article information

Author: Terence Hammes MD

Last Updated: 07/28/2023

Views: 6792

Rating: 4.9 / 5 (69 voted)

Reviews: 84% of readers found this page helpful

Author information

Name: Terence Hammes MD

Birthday: 1992-04-11

Address: Suite 408 9446 Mercy Mews, West Roxie, CT 04904

Phone: +50312511349175

Job: Product Consulting Liaison

Hobby: Jogging, Motor sports, Nordic skating, Jigsaw puzzles, Bird watching, Nordic skating, Sculpting

Introduction: My name is Terence Hammes MD, I am a inexpensive, energetic, jolly, faithful, cheerful, proud, rich person who loves writing and wants to share my knowledge and understanding with you.