Easily Create An NFT App Using The New Infura NFT SDK TypeScript
Tags: typescript, blockchain, webdev, javascript
Published: 2023-01-20 14:06:26

If you know typescript, it’s easy to add the ability to create, mint, and manage non-fungible tokens (NFTs) to your app. The [Infura NFT SDK](https://docs.infura.io/infura/infura-custom-apis/nft-sdk) wraps REST calls to Ethereum nodes, abstracting away the technical compilations and making it possible to work with NFTs with just an Infura account, some configuration, and a few lines of code. The Infura NFT SDK also doesn’t require the overhead of learning Solidity, importing ABIs, etc. Whether you are new to web3 or highly experienced, Infura NFT SDK makes NFTs easy.

Let’s jump in, build, and deploy an ERC721 NFT to see how it works.

## What is the Infura NFT SDK?

The [Infura NFT SDK](https://docs.infura.io/infura/infura-custom-apis/nft-sdk) is an SDK that allows you to build and interact with NFTs easily.  It’s implemented in TypeScript, a programming language that is a strict superset of JavaScript. The SDK includes the ability to create, mint, and manage NFTs and query information about them. 

The significant part is that it abstracts away the technical details so you can focus on the core functionality of your dApp instead of the (often difficult) details. It’s all about ease of use with Infura SDKs!

  
Supported chains include:

**Write**

* Ethereum: Mainnet, Goerli, Sepolia
    
* Polygon: Mainnet, Mumbai
    

**Read**

* Ethereum: Mainnet, Goerli, Sepolia
    
* Polygon: Mainnet, Mumbai
    
* BSC: Mainnet
    

By using the Infura NFT SDK, you also get access to Infura's core functionality and infrastructure, which provides access to Ethereum (and other blockchains) without requiring you to run a full node. With the SDK, you can leverage many capabilities, making it easier to build and scale your dApps.

So let’s build an NFT and see what the SDK can do.

## Building and Deploying ERC721 NFT

We will build a dApp and smart contract on Ethereum and use the SDK to create a new NFT. We’ll do all this on the Ethereum Goerli testnet, so we don’t have to worry about defects or the cost of deploying to the mainnet.

**Prerequisite**

Before getting started, you need the following prerequisites:

* [Node.js](https://nodejs.org/en/) and its package manager NPM. Verify you have Node.js installed by using the following terminal command: node -v && npm -v
    

* [TypeScript](https://www.npmjs.com/package/typescript) installed
    
* [An Infura account](https://docs.infura.io/infura/getting-started)
    
* A basic understanding of TypeScript and JavaScript
    
* [MetaMask](https://consensys.net/docs/consensys-nft/en/latest/tutorials/tuto_1/tuto_1_4/)
    

## **Infura**

The Infura NFT SDK is really simple to use. In fact, most of this tutorial is just the setup and configuration needed to create a dApp. Let’s start by [logging in](https://infura.io/login) to your Infura account. You should be on your dashboard, where you can create a new key, as shown below. We’ll create a new key for this project.

![Infura Dashboard](https://lh4.googleusercontent.com/q-sh4QfIwxBueeyIhF1aWpKfSPA50RMhbn23-LnepDzNk_ssh3WIiKfTeR_iG9m7c9CoIRYOjoIFbzDqcUqeE9Ph4XKO4hCjeborZMN3h43PLaGYjC-gAvmXQOXZoT1hoqwC7KAO0OXNri__VuIZ13EP9S8uzkTIR0eoSmWUMFAUoRZnS67MmMCwpRiSgg)

Click the “Create a New Key” button and fill in the required information.

![Create a New Key](https://lh5.googleusercontent.com/uDpugcXEr6hZ5bnIpQJCHhlfMy-4Xgby8Fz-9yVCTW3Cmn5_9PC4PnO9HZ3_5eumpcS4YoxHGLZxBpTAm8sAyChyLBV2kvgRV5ACXrksen9CHnEOklZBOZJa6sKWcnfWlbwgkLQWNaQ5nwFIFYHkUpD8GdNLfpTtfaNITSwTtCH69K9tJZxpIRwfdypAcg")

After creating your key, your project ID will be visible on your dashboard under the API KEY section, as shown below. Copy and keep it somewhere; you’ll need it later in this tutorial.

![Manage API Key](https://lh4.googleusercontent.com/XMy1EC7RYsua8V0y8USVdLAPiOqIiYNVi68FGeK1WQWYSWReSUK_vEM64NG39LRvYDKxYB1R-vTdLllr-dqmLyCf4eSDUE7nt9EX-ha1hSTBHgXFKtdcwD5LWy1IgaFCFjxeSqAQZw2t0YsS_YlWr8QHymMFnkByOSeNwAUdOE9Wk8x5br4h_eo69egc2g)

## Set up IPFS project on Infura Dashboard

Now, let’s create an IPFS project. [IPFS](https://ipfs.tech/) is a P2P distributed file system for storing and accessing files (and other data). It works well with blockchain. We’ll need IPFS (and these credentials) to upload and store the metadata of our NFT project. 

Head to your dashboard and create another new key by clicking “Create a Key”, as shown below.

![Create IPFS Key](https://lh4.googleusercontent.com/q-sh4QfIwxBueeyIhF1aWpKfSPA50RMhbn23-LnepDzNk_ssh3WIiKfTeR_iG9m7c9CoIRYOjoIFbzDqcUqeE9Ph4XKO4hCjeborZMN3h43PLaGYjC-gAvmXQOXZoT1hoqwC7KAO0OXNri__VuIZ13EP9S8uzkTIR0eoSmWUMFAUoRZnS67MmMCwpRiSgg)

This time we’ll choose IPFS as the network. This project will work on the mainnet and (what we will use it for) testnet.

![Choose the IPFS Network](https://lh3.googleusercontent.com/NudbLlKMFtAmhPX_eiLcJmXmb3Vd0qhW7eJZuBaPpZNXFgdsThfqBwNn13nE1B_iIseds-IDl10ST9CYyqf8WEmWSJoySKYg7VxIWFvYEP32snBTn7NVaTHkyhOX4FkAk_w_-WdClJHj1VAJJ_NFGQOpUedodxJADSXU0uv9n_ff3ZymY7gIJyUeG1tK6Q)

After creating your key, you’ll see your project ID and API key secret under the API KEY section of your dashboard. You’ll need this later as well, so copy it and keep it somewhere safe.

![Copy API KEY and Project ID](https://lh4.googleusercontent.com/5uAFoPoLW6t2KgxvLYiWM5yHNcbrrOuNNPhuzFDrGQYkx4cF4K9tQldKDzvBjNCtbzJJCmWh9LG3T2SgfsISCIUFHmeKipeu0fglYMbs9JNkMowiqb_3j6DZELINfsCOMnh9euG3Ceo0BuFBUZLYoLeqjO9YDyfDX4e5mh7At4l0LyEWrm3DznZhUxtthg)

### Project Setup and Installation

Next, we’ll set up and initialize a node.js Typescript project. Use the following commands in your console:

```bash
mkdir typescript-nft-demo && cd typescript-nft-demo

npm init -y

npm install -D typescript ts-node

npx tsc --init
```

Open the project in your preferred development environment. For example, if you are using Visual Studio Code, use the following command to open the project automatically:

```bash
code .
```

### Install the Project Libraries

Next, we need to install the Infura SDK and dotenv library for reading the environment variables.

Use the following command: 

```bash
npm install @infura/sdk dotenv
```

Your project should have something similar to what is shown below:

![Project structure](https://lh6.googleusercontent.com/PfZkuIF_9pNmH7bD_Cqc4kgcMz2sGyXSfAi_NNkkC7YU5lCQZDL3D5Z-yV_0NrimcbuB9qfkTOlfD1NeDa-fokELlRqR3Ct1jBjVlEiGsj3aWeNWjyg_GuL7TepNuIZbQvJR4_OK3fYz0TP6_NXtiA3H4esnYkmJx9DZK3jlvpjmXXdVCAY4gO0V0WWGEw)

Create a `.env` file at your project's root and add the following variables to it:

```bash
INFURA_PROJECT_ID=<YOUR-INFURA-PROJECT-ID>

INFURA_PROJECT_SECRET=<YOUR-INFURA-PROJECT-API-KEY>

WALLET_PRIVATE_KEY=<YOUR-WALLET-MNEMONIC/PRIVATE-KEY>

EVM_RPC_URL=https://goerli.infura.io/v3/<YOUR-PROJECT-API-KEY>

INFURA_IPFS_PROJECT_ID=<YOUR-INFURA-IPFS-PROJECT-ID>

INFURA_IPFS_PROJECT_SECRET=<YOUR-INFURA-IPFS-PROJECT-SECRET-KEY>

WALLET_PUBLIC_ADDRESS=<YOUR-WALLET-ADDRESS>
```

* Replace `<YOUR-INFURA-PROJECT-ID>` and `<YOUR-INFURA-PROJECT-API-KEY>` with the `ID` and `API` key from the Infura project created earlier in this tutorial.
    
* Replace `<YOUR-INFURA-IPFS-PROJECT-ID>` and `<YOUR-INFURA-IPFS-PROJECT-SECRET-KEY>` with the `ID` and `API` key from the *IPFS*  project created earlier in this tutorial.
    
* On the line starting with `EVM_RPC_URL`, replace `<YOUR-PROJECT-API-KEY>` with your `Infura API key`.
    
* `<YOUR-WALLET-ADDRESS>` should be replaced with your public blockchain address.
    
* `<YOUR-WALLET-MNEMONIC/PRIVATE-KEY>` is your wallet's private key. ***Note: Never share your private keys*** *(mnemonic)* ***with anyone, and keep them secure.***  
    

You can find your wallet address and private key to your wallet on MetaMask in the following steps:

* Open MetaMask by clicking on the browser extension icon or visiting the MetaMask website.
    

![Setup MetaMask](https://lh4.googleusercontent.com/rrqxtgalFtL34J4t-9iWMVRhNyEJr5JVTq7s7yi-OlYzezXGn3OykDWDcJ-VlRATYvEyLpLhmHhEVSXriFiQczkZ2OT3wo4Sv9SXSixJN3A0hBc88lKW5eHgbQYkZisUsOLzLnv-mBgc-zUxk6g_5PqKRKm29QQXW_Cj3jyXtJOTLEqLC3ASfcXKT7n0mA)

* Click on the three dots in the top right corner of the MetaMask window.
    

![Click on the three dots in the top right corner of the MetaMask window](https://lh5.googleusercontent.com/3KTNepuUGplfK7tuwF0Dn4YSXQcOPjaujOr7mNe6njESgG9toj-FIJzOvKzhzdMWVeioVDuTQaUmFg_dpnDp-APzfckXiiwLwfFfW_6e_S8PPreZxtw_GtEerGycPftwfILnCes0XCI16XYGQPa7aBTIan7VqPUjepjvAhGQArOZpOodCUmZq87vWtou_Q)

* Select “Account Details” from the drop-down menu, and click on the “Export Private Key” button.
    

![Select “Account Details” from the drop-down menu](https://lh5.googleusercontent.com/PX68aXVy76z_RDUj0q23qkukWFk9NvTmqR_psvYkJSp50jIsGgRsnZoQTD4Yvj-TzAbsRSTqrHOfAWPB1hFFQken6kyeN8zcD2NoJZKIp4TNQjY1LsGXO5iJq7TCpld8Dvozyid3dKdGbE7ty9DAhrYfsvfHbAclr2Egtk86EOxJd_5ema0IcVM9PyZYdA)

* A pop-up window will appear, asking you to enter your password. Enter your password and click on the “Unlock” button.
    
* Once your account is unlocked, you can see your private key. 
    

<mark>Remember: keep your private key safe and </mark> *<mark>never </mark>* <mark>share your private key with anyone else. Also, be sure you're connected to the Goerli testnet, not the mainnet, as shown in the image below.</mark>

![Extract private key oon MetaMask](https://lh3.googleusercontent.com/F4Txkf7w3MEpjDOlykttZoki5SHSt6MPc_o72gABfWr-059wTseIBFHxDiufN2O4HMNDs_tCxds2Sx58RSwOTlYEgE00IpPzCtysLeU7TGUQKVf0Zz4Hwy3T1BKZt1-tMi7yzmrUPLuMWCPvKdolgdmWv3-Fdsy-uVaV4K96mDQSDm0ZZy7T4PzfBrHMUg)

Now that we’ve successfully configured our project, create a new TypeScript file `nft.ts` at the root level.

Your project structure should look similar to the one below.

![Project structure](https://lh5.googleusercontent.com/oLkILZoQrfzCWFH5_hN-35ctAT3jZ5cWSW1wLujRK2JFaBsKlTJP-81b4Xjz-AE1MFKPnqtG7NtoSW4bf_wO3f3S4fIrGy8OO2jHlXKRz4lX_hcvaHC10mS7IAoen5ZP2Jy3t5xO0YDa_VKlVS7smZZt0LZW6mwsCpEb4_BZyG5cS_5atrfgYNx5fkdOSw)

## Setup Infura Authentication

Authentication from inside our dApp requires our PROJECT\_ID and PROJECT\_SECRET. We’ll load these from our new .env file.

Create an auth object inside the `nft.ts` using the following code snippet:

```typescript
import { config as loadEnv } from "dotenv";
import { SDK, Auth, Metadata, TEMPLATES } from "@infura/sdk";

// load environment variables from .env file
loadEnv();

// Create an instance of the Auth class 
const auth = new Auth({

  // set the projectId taken from the INFURA_PROJECT_ID environment variable 
  projectId: process.env.INFURA_PROJECT_ID,

  // set the secretId taken from the INFURA_PROJECT_SECRET environment variable 
  secretId: process.env.INFURA_PROJECT_SECRET,

  // set the private key taken from the WALLET_PRIVATE_KEY environment variable 
  privateKey: process.env.WALLET_PRIVATE_KEY,

  // set the rpcUrl taken from the EVM_RPC_URL environment variable 
  rpcUrl: process.env.EVM_RPC_URL,

  // set the chainId for the Goerli testnet
  chainId: 5, // Goerli

  // set the options for IPFS
  ipfs: {

    // set the project Id taken from the INFURA_IPFS_PROJECT_ID environment variable
    projectId: process.env.INFURA_IPFS_PROJECT_ID,

    // set the API key secret taken from the INFURA_IPFS_PROJECT_SECRET environment variable
    apiKeySecret: process.env.INFURA_IPFS_PROJECT_SECRET,
  },
});

// Instantiate the SDK
const sdk = new SDK(auth);
```

Configure the `tsconfig.json` file as shown. (You might get an error but keep going.) `tsconfig.json` is a configuration file for TypeScript projects. It’s used to specify the compiler options and files that should be included in the project.

![Configure the `tsconfig.json`](https://lh6.googleusercontent.com/m3K_y890hR2T8kAOI_d__ucqAH-DgiN8QbKxM-wRf8POCeQXPHl3nnVSmQDLjMzoAKTBl70woRjSE0TTna8N0Ry1xCocNcF8yWMTzV64wJXhIh8bySHMxmVMeeSEuh8tp0zPSKCTYdOE6Z-Pf87sg8DSBkKMTPtgBwesbKONxkgwZU3FVmbsKkerjtvtTA)

Configure your `tsconfig.json` with the following code snippet:

```json
{
        "compilerOptions": {

          "target": "ESNext", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */

          "module": "ES2022", /* Specify what module code is generated. */

          // "rootDir": "./",                                  /* Specify the root folder within your source files. */

          "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */

          "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */

          "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */

          /* Type Checking */

          "strict": true, /* Enable all strict type-checking options. */

          "skipLibCheck": true /* Skip type checking all .d.ts files. */
      }
}
```

Next, add the `type` module to the `package.json` file using the following code snippet:

```json
//...

"type": "module",
"scripts": {},

//...
```

## Create Token Metadata

Now we’re done configuring. Let’s get to the exciting stuff!

First, we’ll create the token metadata. 

Token metadata refers to additional information or data associated with a token (typically an ERC-721 or ERC-1155 token on the Ethereum blockchain). This metadata can include information such as the token's name, symbol, image, and other attributes that describe the token or give it context.

The metadata is stored on the blockchain and is typically represented as a URI or a URL that points to a JSON file containing the metadata.

Inside the `nft.ts file`, add the following code snippet. It will create and store the token metadata. The metadata class is from the Infura NFT SDK.

(Note: The [consensys.net](http://consensys.net) external\_url is just for demo purposes here and can be replaced.)  

```typescript
// Define the properties of the token, including its description, external URL, image, name, and attributes
const tokenMetadata = Metadata.openSeaTokenLevelStandard({

  description: "Fantastic creature of different emojis",

  external_url: "https://consensys.net/",

  image: await sdk.storeFile({

    // Store the image from the given URL
    metadata: "https://res.cloudinary.com/olanetsoft/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1672327921/demo.jpg",

  }),
  name: "Kandy Jane",
  attributes: [],
});

// Log the token metadata object to the console
console.log("Token Metadata: ", tokenMetadata);


// Store the token metadata and log the result
const storeTokenMetadata = await sdk.storeMetadata({ metadata: tokenMetadata });

console.log("Store Token Metadata: ", storeTokenMetadata);
```

## Create the Contract Metadata

Contract metadata refers to additional information or data associated with a smart contract on a blockchain network. This metadata can include information such as the contract's name, symbol, version, and other attributes that describe the contract or give it context.

The metadata is stored on the blockchain and is typically represented as a URI or a URL that points to a JSON file containing the metadata.

Create contract metadata using the following code snippet:  

```typescript
//...

// Define the properties of the collection, including its description, external URL, image, name, and attributes
const collectionMetadata = Metadata.openSeaCollectionLevelStandard({

  name: "Emojis collection", // Sets the name of the collection to "Emojis collection"

  description:
    "A small digital image or icon used to express an idea or emotion in electronic communication. Emoji's come in many forms, such as smiley faces, animals, food, and activities. ", // Sets the description of the collection
  image: await sdk.storeFile({

    // Sets the image property of the collection using the storeFile method
    metadata:
"https://res.cloudinary.com/olanetsoft/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1672327921/demo.jpg", // The URL of the image file
  }),

  external_link: "https://google.com/", // Sets the external link property of the collection
});

// Logs the collection metadata to the console
console.log("Collection Metadata:- ", collectionMetadata); 

// stores the metadata using the storeMetadata method
const storeMetadata = await sdk.storeMetadata({ metadata: collectionMetadata }); 

// Logs the store metadata to the console
console.log("Store Metadata: ", storeMetadata); 
```

This code snippet above creates an object `collectionMetadata` using the `openSeaCollectionLevelStandard` method from the Metadata class. The `openSeaCollectionLevelStandard` method creates standard collection-level metadata compatible with [OpenSea](https://opensea.io/), a leading marketplace for NFTs. It sets the collection's name, description, image, and external link properties; stores the metadata using the `storeMetadata` method; then logs it and stores it in the console for debugging.

## Create a New Contract and Mint an NFT

Add the following code to create a new contract and mint an NFT using the Infura NFT SDK. Most of this functionality comes to us from our new NFT SDK!

```typescript
//...

// Create a new contract
const newContract = await sdk.deploy({   // deploys a new contract using the sdk.deploy method

  template: TEMPLATES.ERC721Mintable,     // sets the template for the contract to ERC721Mintable
  params: {
    name: "1507Contract",                  // sets the name of the contract as "1507Contract"
    symbol: "EMOJI",                        // sets the symbol of the contract as "EMOJI"
    contractURI: storeMetadata,             // sets the contract URI with the storeMetadata
  },
});

console.log("Contract Address: \n", newContract.contractAddress);  // logs the contract address to the console

// mint an NFT
const mint = await newContract.mint({  // mints a new NFT using the mint method from the new contract

  publicAddress:
    process.env.WALLET_PUBLIC_ADDRESS ??

    "0x510e5EA32386B7C48C4DEEAC80e86859b5e2416C", // sets the public address of the wallet, if not set it will use the given address

  tokenURI: storeTokenMetadata,                // sets the token URI with the storeTokenMetadata

});

const minted = await mint.wait();            // waits for the minting process to complete

console.log("Minted: ", minted);               // logs the minted NFT to the console
```

This code creates a new contract using the `sdk.deploy` method and sets the template for the contract to `ERC721Mintable`. Then it sets the contract's name, symbol, and contract URI. The contract address is logged for debugging.

It then mints a new NFT using the `mint` method from the new contract and sets the wallet's public address. If not specified, it uses the given address and then sets the token URI with the `storeTokenMetadata`.

Finally, it waits for the minting process to complete and logs the minted NFT to the console.

Let’s test it out!

```bash
ts-node-esm nft.ts
```

You should see something similar to what is shown below:

![Project review](https://lh5.googleusercontent.com/bcAOFivZ81CLYvT8Cnum8St24rGH7q1eNilgVuW8vhwTqhmO3QWCI25HNhvJPyoqZT3-Tp_wLdLdLsu5B0-xwIfObeH-IffGqrFSRVd4dPETXmup1N_-54DlDSIWhUPvr50wsCKLwzRO0rf7kYdXo6NopMtgDCPfUgYp5P3jw4UDNebQHRB0vi3_KO_omw)

## Verify Contract on Account and Goerli Etherscan

Finally, let’s verify the contract using a blockchain explorer on the [Goerli Etherscan](https://goerli.etherscan.io/). Go to the [Goerli Ethereum testnet site](https://goerli.etherscan.io/) and paste the transaction hash from your output above (as shown below).

![Verify Contract on Account and Goerli Etherscan](https://lh6.googleusercontent.com/DQmHhg8WVXeDHoQ6TeiVgqgv3sBTJ7L3bVpGkWbkF1W1wswrHX8zPfqh1BiYRJEXDBMnaAgS0qR1xYlqUX8GXKVjOacrXZezCAIcG2-y0E2q3QiOm6c2Bk6oUN7HvazFS42FXKgHrykhFr9GHWSjvz-1U6HLk2GXHfB0XOCYW_29uD5ZlW6RvOaZmNI1gQ)

You should see the details.

![Verify Contract on Account and Goerli Etherscan](https://lh4.googleusercontent.com/n5mTSEW6_G3Hg-rtD6Ng3Lq30p7NspF_3f7u6mFKiga03OQmsTZ2iJcQSXTI_PjQYune1BJzuvTeJKWviMKZ6clvt5o3u9v4ycRiECWp-gp5zh4Cr_W0d_uzHMh-E67sUkoR0Gw-fa28bFmc7cPku2sKPACguQ0lj977qnA2hIYtkAaGn7295GBDkBBp7w)

That was easy! We successfully utilized the Infura NFT SDK to build, deploy, and mint an NFT on the Goerli testnet.

## Import token on MetaMask

Let’s look at our new NFT from a front-end perspective using MetaMask. First, we have to import our wallet to MetaMask. Click “Import Tokens”, as shown in MetaMask. (Be sure you are connected to the Goerli Testnet as shown.)

![Import token on MetaMask](https://lh3.googleusercontent.com/Nw8e3QWqdUBNS71_SfdUdGSVvhNeCgky7MEK0A1HhJkSrOiIWZklUZG-ySFXx7h6mmI6uObI3TVLCtZ5EJPUaH1ZELGcHsSI3R0wNl_46NxDqfzVXWbXhB3tV0AfUsld8hS60VKOLSZEqkNRLQPAW3e6Z4me34HDJuxpz4x0LKC7BNslfcSMpsnpo9q7UA)

![Import token on MetaMask](https://lh3.googleusercontent.com/9UZocvQnZ866WmwRvH0f8Bj3iuVD0hGESziyGQxCJ7kJ83NOIolJSy0e2y0V1pahk36QQBxQ1Na0Ts1ZEYahxCurYLjbpnnGFBt0Xj5tHx0uCBHn2Q3TRIxGZuuq-jSvFRjIhP309sMr8xWJC9jQ5sgQuddwYQ0Ke0dh2qE4mmpaVe95jSgxpICbtIUy9g)

Copy and paste the contract address to import your token on MetaMask, as shown below.

![Copy and paste the contract address to import your token on MetaMask](https://lh3.googleusercontent.com/cZIm0jbz_xYA6_hGq7p5GH-aZZeeJwxziPMoasmrfhscbB2YvPN4vUL-UY6it2QNk2JgnSBNAAZEJR8JtOXGI2t7t__NGCnd31m4ryJShRIeth8KHr6UR_Uz6AHq2ImRyg-GrIqiV7z5zWhaDhzqAjlDJuMLS38ysxjyhDIATlDABDBFhocMGTg6rbgN0g)

And there it is! An easy and fast way to add NFTs to your dApps. You can use the SDK now to manage the NFTs and more ([see the docs for current capabilities](https://docs.infura.io/infura/infura-custom-apis/nft-sdk)).

## Verify Minted NFT on OpenSea

We’ve successfully imported the minted NFT on MetaMask, but now let’s verify on [OpenSea tesnet](https://testnets.opensea.io/). Connect your wallet and view your new NFT. You should have something similar to what is shown below.

![Verify Minted NFT on OpenSea](https://lh4.googleusercontent.com/G5wUmb6mX588wWBv6gvwZIAJsjY6qHftXZWqcUrMgSYFezsVMO41guJS7XJllrHq-DkFPyC5FomNxz_ru0RQTT3wcDmIVxwSy0LABO_jEyZaSRmAdjUJN5kDUoSEoXw1YtnvrS1cgPgloScNU7P_wYgcz2DCpzrHAqq3k94QLEGjgq8KbaWYbBLhBOUY-Q)

For reference, [here’s the OpenSea link](https://testnets.opensea.io/assets/goerli/0x7d29d142ca8e60139d14fe2ebf1e353e579ed8f6/0) to the NFT created. You can find the complete code on a GitHub repository [here](https://github.com/Olanetsoft/nft-demo-with-typescript).

## Conclusion

In conclusion, the new Infura NFT SDK for TypeScript is a powerful tool for developers looking to incorporate NFTs into their dApps. With its easy-to-use functions and comprehensive features, this SDK makes it simple to deploy, mint, and manage NFTs on the Ethereum blockchain. [Sign up and start building](https://www.npmjs.com/package/@infura/sdk)!

  
I'd love to connect with you on [**Twitter**](https://twitter.com/olanetsoft) | [**LinkedIn**](https://www.linkedin.com/in/olubisi-idris-ayinde-05727b17a/) | [**GitHub**](https://github.com/Olanetsoft) | [**Portfolio**](https://idrisolubisi.com/)

See you in my next blog article. Take care!!!