Last updated: November 2026
Part of our NFT Guide: how NFTs work, costs, risks and real uses in one place.
Quick answer: a dynamic NFT (dNFT) is an NFT whose metadata, such as its image, level or stats, can change after minting when a condition is met. The token ID and owner stay the same; only what the NFT shows or represents changes. Developers build them with a normal ERC-721 or ERC-1155 contract, an oracle or automation service (often Chainlink) to trigger updates, and the ERC-4906 standard so marketplaces know when to refresh the NFT.
Dynamic vs static NFTs
| Static NFT | Dynamic NFT | |
|---|---|---|
| Metadata after mint | Fixed | Can change under rules in the contract |
| Typical use | Art, PFP collections, collectibles | Games, loyalty, memberships, sports, real-world assets |
| Needs external data? | No | Often (oracle, API, game server) |
| Main risk | Image hosted on a server that goes offline | Who controls updates, broken or manipulated updates |
| Trust question | Is the media stored permanently? | Can the creator change your NFT in ways you did not expect? |
How dynamic NFTs work
- Mint: the NFT is created with an initial state (for example level 1, or “season 1” art).
- Trigger: something happens on-chain (a transfer, a vote, a game action) or off-chain (a sports result, weather, a price feed).
- Data delivery: an oracle such as Chainlink delivers off-chain data to the contract, or an automation service calls the contract when conditions are met.
- Update: the contract changes stored traits or the token URI.
- Refresh: the contract emits an ERC-4906
MetadataUpdateevent so marketplaces and wallets refetch the new metadata.
Why ERC-4906 matters
Marketplaces cache NFT metadata. Without a signal, a changed NFT can look the same for days. ERC-4906 defines two events, MetadataUpdate for one token and BatchMetadataUpdate for a range, so platforms know exactly when to refresh. If you build a dNFT, emit them.
ERC-721 or ERC-1155?
Both work. Many guides say dynamic NFTs “use ERC-1155”, but the dynamic behavior comes from the contract logic, not the token standard. ERC-721 is common for one-of-one items that evolve; ERC-1155 suits games with many item types.
Real dynamic NFT examples
- Sports collectibles: LaMelo Ball’s NFT collection included tokens that changed based on his on-court stats, using Chainlink data.
- Art: Beeple’s “Crossroad” was designed to show a different final image depending on the 2020 US election result.
- Games: characters and items that level up, gain traits or wear down as you play.
- Loyalty and memberships: a membership NFT that moves from silver to gold tier as you collect points. See our guide to NFT loyalty programs.
- Real-world assets: an NFT that tracks the status of a physical item, certificate or ticket.
How to build a simple dynamic NFT
This minimal Solidity example uses OpenZeppelin v5. ERC721URIStorage already implements ERC-4906 and emits MetadataUpdate whenever the token URI changes.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {ERC721URIStorage, ERC721} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
contract LevelNFT is ERC721URIStorage, Ownable {
uint256 private _nextId;
mapping(uint256 => uint8) public level;
string[3] private _levelURIs;
constructor(string[3] memory uris) ERC721("Level NFT", "LVL") Ownable(msg.sender) {
_levelURIs = uris;
}
function mint(address to) external onlyOwner returns (uint256 id) {
id = _nextId++;
_safeMint(to, id);
_setTokenURI(id, _levelURIs[0]);
}
// Called by your game server, an automation job or an oracle callback.
function levelUp(uint256 id) external onlyOwner {
require(level[id] < 2, "Max level");
level[id] += 1;
_setTokenURI(id, _levelURIs[level[id]]); // emits MetadataUpdate (ERC-4906)
}
}Next steps for production:
- Replace
onlyOwnerwith a role for the updater (for example Chainlink Automation or a Functions callback), so updates follow clear rules. - Store media permanently on IPFS or Arweave, and publish all possible states up front so holders can see what can change.
- Use Chainlink VRF if updates involve randomness, so results cannot be manipulated.
- Deploy on a low-fee network if updates are frequent. Each update is a transaction; see our guide to NFT gas fees.
- Test on a testnet and check that OpenSea and other marketplaces refresh after each update.
Risks and things to check before buying a dNFT
- Who can update it? If one wallet can change any NFT at any time, the creator can also change it in ways holders dislike.
- Is the logic on-chain? On-chain rules are more predictable than “the team updates metadata on our server”.
- What happens if the project stops? If updates depend on the team’s server, the NFT may freeze in its last state.
- Value can go down: a dNFT tied to performance can lose traits or value if the condition goes the wrong way.
This article is for information only and is not financial advice.
FAQ
What is the difference between a dynamic NFT and a regular NFT?
A regular (static) NFT keeps the same metadata forever. A dynamic NFT can change its metadata after minting based on rules written in its smart contract.
Do dynamic NFTs need Chainlink?
No. Chainlink is a common choice for external data and automation, but a dNFT can also update from on-chain events, other oracles or a trusted updater account.
Why doesn’t my dynamic NFT update on OpenSea?
Usually because the contract does not emit an ERC-4906 MetadataUpdate event, or the marketplace has not refreshed its cache yet. Emit the event and use the marketplace’s “refresh metadata” option.
Are dynamic NFTs more expensive?
Minting costs about the same, but every on-chain update is a transaction with a gas fee, and oracle services may charge fees too.
Sources
- Chainlink: What is a dynamic NFT?
- Chainlink: Dynamic NFT use cases
- Ethereum EIP-4906: EIP-721 Metadata Update Extension
- OpenZeppelin Contracts 5.x: ERC-721
- CoinDesk: What are dynamic NFTs?
Related: how to create and mint an NFT and NFT staking platforms.

No comments yet