NFTs — Guides

Introduction

A non-fungible token (NFT) is a record on a blockchain that proves ownership of a specific digital asset. In Web3 games, that asset is often a card, avatar, skin, land plot, or item. What lives on-chain is typically a token ID (and a balance for certain standards) inside a smart contract—not the image file itself.

Games can be fully playable without NFTs. When collectibles exist, they are usually optional: they enable trading, collection, and sometimes reward programs—not always a competitive advantage over free in-game items.

NFTs in Web3 gaming — overview illustration

What you actually own

Think in three layers:

On-chain

Contract address + token ID (+ balance for ERC-1155)

0xABC… token #42, balance 3

Metadata

Off-chain JSON: name, image, attributes

Card name, art URL, rarity trait

Marketplace

Listings, floor price, buy/sell UI

OpenSea, TokenTrove

The blockchain enforces who owns which token. Metadata makes the token readable in wallets and on sites like Web3Raider. Prices usually come from marketplaces, not from the NFT contract itself.

Note: Metadata can be changed if a project updates URIs or hosting. For valuable assets, rely on official contracts and marketplace links from the game studio.

Diagram: on-chain ownership, metadata, and marketplace layers for an NFT

ERC-721: one unique token per ID

ERC-721 is the original NFT standard on Ethereum. Each token ID represents a distinct asset. One ID has one owner at a time (except during a pending transfer or sale).

Common in gaming

Unique avatars and profile collectibles
1/1 items, exclusive characters, single land parcels
Projects where every mint is its own on-chain ID

How to read it on Web3Raider

Expect one catalog row per token ID, often with effective supply 1
If you see the same name and artwork on different IDs, those are separate mints with similar metadata—not one stackable item type

In our catalog: Parallel Avatars on Ethereum is a typical ERC-721-style collection (unique IDs per avatar).

ERC-721 example: unique token IDs as separate digital collectibles

ERC-1155: one token type, many copies

ERC-1155 is a multi-token standard. A single contract can manage many token IDs. Each ID has its own supply: how many units exist for that type.

Supply = 1 → behaves like a unique NFT for that ID
Supply > 1 → fungible or semi-fungible copies (e.g. thousands of the same card)

Common in gaming

Trading card games and fixed-edition card sets
Stackable items, consumables, and mixed economies in one contract
Batch transfers (move several IDs in one transaction), often cheaper than many ERC-721 transfers

How to read it on Web3Raider

We aim to show one entry per token type with a supply count (how many units exist for that ID)
This matches how TCG and item collections are designed on-chain

In our catalog: Parallel Alpha Cards, Planetfall, and Deception are documented as ERC-1155 on Ethereum or Base.

ERC-1155 example: one token ID with multiple copies (supply greater than one)

ERC-721 vs ERC-1155 at a glance

	ERC-721	ERC-1155
Identity	Each token ID is unique	Each token ID is a type; supply can be 1 or many
Typical supply per ID	1	1 to millions
Gas (many items)	Often higher (one transfer per token)	Often lower (batch transfers)
Best for	1/1 collectibles, unique characters	TCG cards, stackable items, mixed asset contracts
Web3Raider list view	One row per token ID	One row per token ID + supply

Neither standard replaces the other. Many ecosystems use both: for example, unique avatars (721-style) and card sets (1155-style) in the same franchise.

Metadata and collection images

The blockchain records who owns which token. It does not store the card art, name, or traits directly—storing large files on-chain would be slow and expensive. Instead, the contract stores a link (a URI) to a JSON file hosted elsewhere. Wallets, marketplaces, and Web3Raider follow that link to show you the NFT.

Think of it like a library catalog number on the shelf (on-chain) versus the full book description and cover image in the database (off-chain metadata).

Two levels of metadata

Collection (whole set)

Function: contractURI() on the smart contract

Used for the collection name, description, and cover / banner image—what you see on a marketplace collection page before opening individual items.

Single token (one card or item)

Function: tokenURI(tokenId) (ERC-721) or uri(tokenId) (ERC-1155)

Used for that token’s name, image, and attributes (rarity, faction, class, etc.)—what you see on each NFT card in a grid.

What happens when you view an NFT

Your wallet or a site reads the contract address and token ID on-chain.
It calls the contract and gets a URI string (often https://… or ipfs://…).
It downloads the JSON at that URI.
It loads the image URL inside the JSON and displays name + traits.

That JSON is the metadata for that token. A simplified example:

{
  "name": "Example Card",
  "description": "Short description of the asset.",
  "image": "ipfs://bafy.../card.png",
  "attributes": [
    { "trait_type": "Rarity", "value": "Legendary" },
    { "trait_type": "Faction", "value": "Earthen" }
  ]
}

Field	What it means
name	Display title (e.g. card or character name)
description	Longer text; optional
image	Link to the artwork (PNG, GIF, etc.)
attributes	Traits for filters and rarity (common in games)

IPFS in one sentence

Many projects use IPFS (ipfs://…): the link points to content by a fingerprint (CID), not a single company’s server. If the file changes, the link changes—which makes tampering easier to spot. Apps usually resolve ipfs:// to an HTTPS gateway so images load in the browser.

Collection images vs marketplace images

From the contract (contractURI): the project’s official collection metadata—what indexers like Alchemy often use for collection covers.
From marketplaces (e.g. OpenSea): extra curation, banners, and floor prices—helpful for trading, not always identical to on-chain metadata.

When Web3Raider shows a collection cover, we prefer official on-chain or curated static assets; live token grids use per-token metadata from indexers.

Flow from smart contract token URI to metadata JSON to image and traits

Marketplaces and trading

Buying and selling usually happen on a marketplace, not inside the NFT contract:

Connect a wallet on the correct chain (Ethereum, Base, Immutable, etc.)
Approve the marketplace to transfer your NFT when you list or sell
Pay in the currency the listing uses (ETH, POL, etc.)

Web3Raider lists official marketplace links per collection on /nft. We plan to add floor prices and per-item deep links over time. Today, the focus is catalog discovery and education.

Trading involves risk, fees, and regional availability. Always use links from the game’s official site or our collection pages.

How to use this guide on Web3Raider

Open a game page and scroll to Collections, or browse all NFT collections.
Open a collection to see chain, description, marketplace links, and (where configured) on-chain assets.
Use ERC-721 vs ERC-1155 above to interpret token IDs, supply, and traits in the grid.

When we integrate live asset data (e.g. via indexers), card rows will emphasize one row per asset type with supply for ERC-1155 sets such as Parallel.

Web3Raider NFT collection and game catalog browsing flow