I want to create a non-transferable token to re… | Parse
I want to create a non-transferable token to represent an achievement. Which token standard is best for this?
Data as of Sep 26, 2026 · Based on 505 AI responses from ChatGPT Search and Google AI Mode · See how Parse measures this
For creating non-transferable tokens to represent achievements, EIP-5192 (Minimal Soulbound NFTs) is the current gold standard. It is widely recommended for its simplicity and direct support for locking tokens to a specific wallet. While other standards like EIP-4973 exist, EIP-5192 is consistently preferred for its clear implementation as a reliable, non-transferable token format.
For representing non-transferable achievements (often called credentials, badges, or Soulbound Tokens), the best approach is to use a Soulbound Token (SBT) standard.
In the EVM ecosystem, non-transferable tokens generally fall into two leading standard paths, depending on whether you want full compatibility with standard NFT marketplaces or a standalone account-bound design:
ERC-5484 (Consensus-Based Soulbound NFT) : Built as an extension of the ubiquitous ERC-721 standard. It overrides transfer functions to make them permanently non-transferable while adding a clear burn-authorization specification (issuer-only, receiver-only, or mutual). Because it inherits from ERC-721, it has the best out-of-the-box compatibility with existing wallets, block explorers, and NFT infrastructure. You can read more about the specification details on the EIP-5484 Proposal (or general breakdowns on Cyfrin's SBT Explainer).
ERC-4973 (Account-Bound Tokens) : Designed as "ERC-721 for Account-Bound Tokens". Instead of relying on traditional NFT smart contract layouts, it uses an explicit request-and-consent flow where tokens are bound directly to a recipient address without implementing a canonical transfer API. It is ideal if you want achievements to be explicitly signed and accepted by the recipient. You can review the specification on the EIP-4973 Standard.
Recommendation:ERC-5484 is typically preferred for achievements and badges because wallet and explorer integration is seamless since it treats the token natively like an ERC-721 under the hood, just with transfers disabled.
If you'd like, let me know:
Which blockchain network you plan to deploy on
Whether the user should have the ability to burn/delete their achievement badge
If the achievement needs an issuer-revocation mechanism
I can help you select the exact implementation pattern or provide a contract structure.
For a non-transferable token representing an achievement (certificate, badge, credential, award, reputation marker), the usual best fit is a Soulbound Token (SBT). If you are building on an Ethereum-compatible (EVM) chain, the default choice is:
Recommended: ERC-5192 + ERC-721
ERC-5192 is a minimal extension of ERC-721 that adds a standard way to indicate that an NFT is locked and non-transferable. It introduces the locked(tokenId) interface so wallets and applications can recognize that the token is soulbound rather than merely discovering that transfers fail.
If the achievement might need to be withdrawn (for example, a certification expires or was issued incorrectly), consider ERC-5484. It adds standardized burn authorization rules so you can define whether the issuer, recipient, both, or neither can burn the token.
For a non-transferable achievement token, the best default choice is ERC-5192 (Minimal Soulbound NFT) built on ERC-721.
Use:
ERC-5192 + ERC-721 → achievement badges, course completions, awards, reputation markers. ERC-5192 adds a standard way for apps to detect that an NFT is locked/non-transferable.
ERC-5484 → if the achievement needs defined revocation rules (for example, a certification that can expire or be withdrawn).
ERC-1155 + non-transferability extensions → if you issue large volumes of identical badges.
Typical design:
Mint an ERC-721 token to the recipient.
Mark it locked via ERC-5192.
Store metadata: achievement name, issuer, date earned, evidence URI, and optional expiry/revocation data.
One important choice: decide whether achievements can ever be revoked. If yes, design that into the contract from the start; if no, a permanently locked ERC-5192 token is usually the simplest approach.
For a non-transferable token representing a unique achievement, the best and most widely adopted standard is ERC-5192 (Minimal Soulbound NFTs).
Why ERC-5192 is the Best Choice
Extension of ERC-721: It builds directly on top of the standard NFT interface (ERC-721 ), meaning it is natively compatible with most existing NFT infrastructure, marketplaces, and developer tools.
Adds a locked State: It introduces a simple locked(uint256 tokenId) view function. When it returns true , all transfer functions for that token are disabled and will revert/throw an error.
Standardized Detection: It integrates with ERC-165 , allowing wallets, explorers, and apps to programmatically recognize that the token is permanently bound to the recipient's address (acting as a true Soulbound Token or SBT).
Alternative Approaches
Plain Custom ERC-721 with Overrides: Many developers simply override the _update or transferFrom functions in a standard ERC-721 contract to always revert if a transfer is attempted. However, doing this without a standard like ERC-5192 means external applications and wallets won't natively understand why the transfer fails or recognize it as a legitimate soulbound achievement badge.
ERC-5727: A more complex framework for semi-soulbound tokens that handles finer lifecycle management, expiration, and recovery options. It is overkill if you just want a clean, straightforward digital achievement badge.
If you'd like, I can:
Share a Solidity code template for an ERC-5192 achievement token
Discuss how to handle metadata and IPFS storage for the achievement art/details
ERC-5192 is specifically designed as an extension to ERC-721 for soulbound, non-transferable NFTs. A compliant token exposes a locked(tokenId) interface, and when locked, transfers must fail. Wallets and applications can also detect the soulbound capability through ERC-165.
For example, your achievement could look conceptually like:
Specifically designed around non-tradable tokens, but currently stagnant
Plain ERC-721
Transferable achievements
Not inherently non-transferable
ERC-1155 is particularly useful if you have something like 100,000 users all earning the same "Completed Course X" badge, because one contract can represent many token types. There are extensions such as ERC-5633 for making individual ERC-1155 token IDs soulbound.
One important design consideration
I'd distinguish "non-transferable" from "permanently immutable."
For achievement credentials, you may want the issuer to be able to:
revoke an achievement if it was awarded incorrectly;
replace/reissue it if the user's wallet is lost;
update metadata;
potentially burn and reissue credentials.
ERC-5192 establishes the non-transferability interface, but the precise issuance, revocation, and recovery model is up to your contract design.
My default architecture would therefore be:
ERC-721 + ERC-5192, with issuer-controlled minting and an explicit revocation mechanism.
If you're building this for certificates, course completions, game achievements, professional credentials, or POAP-like badges, I can also sketch the Solidity contract architecture and explain how I'd handle revocation, wallet recovery, metadata, and privacy.
ERC-1155 is particularly useful if you have something like 100,000 users all earning the same "Completed Course X" badge, because one contract can represent many token types. There are extensions such as ERC-5633 for making individual ERC-1155 token IDs soulbound.
One important design consideration
I'd distinguish "non-transferable" from "permanently immutable."
For achievement credentials, you may want the issuer to be able to:
For a non-transferable token representing a unique achievement, credential, or badge, the best choice is a Soulbound Token (SBT) built as an extension of the standard ERC-721 non-fungible token framework.
Achievements are inherently unique (non-fungible), making ERC-721 the ideal base layer. To make them non-transferable, the community relies on specific SBT standards. The top options depend on your specific needs:
ERC-5484 (Consensual Soulbound Tokens): This is widely considered the gold standard for formal credentials and achievements. It builds directly on ERC-721 and adds a standardized burn authorization feature. It lets you specify upfront whether only the issuer, only the receiver (holder), both, or neither can burn (revoke/destroy) the token. It also requires mutual consent at issuance and signals clearly to marketplaces/wallets that the token shouldn't be tradable.
ERC-5192 (Minimal Soulbound NFTs): If you just want a lightweight, straightforward "soulbound" flag on a regular ERC-721 token without extra governance or complex burn logic, ERC-5192 is a popular minimal interface. It adds a simple locked(uint256 tokenId) function that returns true, letting wallets and marketplaces instantly know the token is permanently locked to the owner's address.
Modified ERC-721 (Custom Override): Many projects still opt for a custom implementation of ERC-721 where the _update or _transfer functions are overridden to explicitly revert (throw an error) on any transfer attempts (except for the initial mint and final burn). While simple to code, it lacks a universal interoperable standard signal for external dApps compared to ERC-5484 or ERC-5192.
Recommended Approach
Use ERC-5484 if your achievement needs clear revocation rules (e.g., an issuer revoking a credential if conditions change). Use ERC-5192 or a basic overridden ERC-721 if you just need a permanent, unchangeable digital badge of honor that sits in a user's wallet forever.
If you'd like, let me know:
Who or what is issuing the achievement (a smart contract, a DAO, or an admin wallet)?
Do you need the ability to revoke the achievement later on?
I can help outline the solidity implementation pattern or point you toward starter contracts.
To represent a non-transferable achievement, credential, or badge on-chain, you are looking for a Soulbound Token (SBT) or Account-Bound Token (ABT) standard.
Instead of writing a custom ERC-721 contract and overriding/reverting the transfer functions (which breaks standard NFT marketplace compatibility), specific standards exist for this.
The best token standards for achievements include:
ERC-5484 (Consensual Soulbound Tokens)
What it is: An extension of ERC-721 that makes tokens non-transferable while adding an immutable burn authorization rule.
Why it’s great for achievements: It requires mutual consent between the issuer and receiver before minting. It also defines who has the right to burn (destroy) the achievement later on (e.g., only the issuer if a credential expires or is revoked, or only the holder if they want it removed). Because it builds directly on ERC-721 , it remains compatible with standard NFT toolsets while signaling clearly that it cannot be transferred.
ERC-4973 (Account-Bound Tokens)
What it is: Often described as "the non-NFT" counterpart to ERC-721. It implements a way to tether a token explicitly to a specific Ethereum address without utilizing the standard ERC-721 transfer methods.
Why it’s great for achievements: It features a "consensual minting" mechanism where the recipient must actively accept/sign for the achievement, preventing third parties from spamming or "airdropping" unwanted or embarrassing badges to user wallets.
ERC-5192 (Minimal Soulbound Tokens)
What it is: A ultra-lightweight interface extension for ERC-721 that adds a single boolean function: locked(uint256 tokenId).
Why it’s great for achievements: If you want to keep standard NFT minting mechanics but simply need a universally recognized flag that says "this achievement is locked/non-transferable," this is the simplest standard to adopt.
Recommendation Summary
Use ERC-5484 if you need robust rules regarding revocation and consent (ideal for professional/educational achievements).
Use ERC-4973 if you want a pure account-bound badge that requires user opt-in/signature to claim.
Use ERC-5192 if you just want a dead-simple extension on top of a standard ERC-721 contract.
If you'd like, let me know:
Do you need the issuer to be able to revoke/burn the achievement later?
Should the user pay to mint it, or will you distribute it for free?
I can help you pick the exact standard and outline the basic Solidity implementation approach.
If you’re building on Ethereum or another EVM-compatible chain, the most direct fit is ERC-5192 (Minimal Soulbound NFTs).
ERC-5192 is specifically designed for non-transferable NFTs: it extends ERC-721 and provides a standard locked(tokenId) interface so wallets and applications can detect that the token is permanently/non-transferably bound to an account.
Which standard to use?
Standard
Good fit when
ERC-5192
A unique achievement/badge should simply be non-transferable
ERC-5484
The achievement may need standardized issuer/holder revocation (burn) rules
ERC-4973
You specifically want an account-bound token model rather than an ERC-721 NFT
For a typical achievement system, I'd structure it as:
ERC-721 + ERC-5192
For example:
Alice completes a course → your contract mints Achievement #123 to Alice → the token contains the achievement metadata → Alice cannot transfer it to another wallet.
ERC-5192's important distinction is that it doesn't merely rely on your contract making transferFrom() revert; it gives other applications a standardized way to discover that the NFT is locked.
One important design question
I'd decide revocation before implementing the contract.
Achievement can never be revoked: ERC-5192 is a straightforward choice.
Issuer may need to revoke it: consider ERC-5484, which specifically defines burn authorization for soulbound tokens.
User might lose access to their wallet: think about recovery/account migration separately, because soulbound ownership is fundamentally tied to an account.
If you tell me whether the achievement needs revocation and which chain you're using (Ethereum, Base, Polygon, Arbitrum, etc.), I can give you the recommended contract architecture and Solidity implementation.
Standard
Good fit when
ERC-5192
A unique achievement/badge should simply be non-transferable
ERC-5484
The achievement may need standardized issuer/holder revocation (burn) rules
ERC-4973
You specifically want an account-bound token model rather than an ERC-721 NFT
For a typical achievement system, I'd structure it as:
ERC-721 + ERC-5192
For example:
Alice completes a course → your contract mints Achievement #123 to Alice → the token contains the achievement metadata → Alice cannot transfer it to another wallet.
ERC-5192's important distinction is that it doesn't merely rely on your contract making transferFrom() revert; it gives other applications a standardized way to discover that the NFT is locked.
One important design question
I'd decide revocation before implementing the contract.
For representing an achievement (like a credential, badge, or milestone), a Non-Transferable Token —commonly referred to as a Soulbound Token (SBT) —is the ideal choice.
Because achievements are unique to an individual and cannot be traded or sold, you need a standard that enforces this restriction. Several options exist depending on your architectural preferences and ecosystem compatibility:
Overridden ERC-721 (The Pragmatic Industry Standard) : You take the standard ERC-721 NFT contract and override the internal _update or _beforeTokenTransfer hook to revert (throw an error) on any transfer attempts where from and to are non-zero (allowing minting and burning, but blocking peer-to-peer transfers).
Pros : Maximum compatibility with existing wallets, marketplaces (which will gracefully show it as untradeable), and libraries like OpenZeppelin.
Cons : Carries unused transfer bytecode logic intended for standard NFTs.
ERC-5484 (Consensual Soulbound Tokens) : An extension of ERC-721 that explicitly introduces immutable burn authorizations agreed upon by both the issuer and receiver before minting.
Pros : Great for credentials or achievements where either the issuer or the holder needs a pre-determined right to destroy (burn) the token later.
ERC-4973 (Account-Bound Tokens) : An experimental standard that provides an alternative API for account-bound tokens without relying on the traditional ERC-721 transferFrom framework.
Pros : Cleanly separates account-bound logic from standard transfer mechanics.
Cons : Lower adoption across standard consumer wallets compared to vanilla ERC-721 overrides.
Recommendation
For a straightforward achievement badge, overriding OpenZeppelin’s ERC-721 implementation to block transfers is still the most widely adopted and frictionless route. It ensures that popular wallets and block explorers immediately recognize, index, and display your achievement token correctly.
Would you like me to share a Solidity code snippet using OpenZeppelin to disable transfers, or do you have a specific blockchain network in mind for deployment?
For an achievement that should be non-transferable, the most straightforward choice on an EVM-compatible chain is ERC-721 + ERC-5192 (Soulbound NFT).
ERC-721 gives you the standard NFT structure: unique token IDs, ownership, metadata, etc.
ERC-5192 adds a standardized way to signal that an ERC-721 token is locked/non-transferable. A locked token's transfer operations must revert, and wallets/apps can detect the soulbound interface via ERC-165.
ERC-5192 is a Final Standards Track ERC, so it's preferable to simply inventing your own "revert transfers" convention.
Which variant fits?
Requirement
Good fit
Simple achievement/badge
ERC-721 + ERC-5192
Achievement can be revoked by issuer
ERC-721 + ERC-5192 + issuer burn/revocation logic
Recipient must explicitly consent to receiving it
ERC-5484
Thousands/millions of identical achievement badges
ERC-1155 + a non-transferability extension such as ERC-6268
Credential needs strong privacy / isn't really an NFT
Consider verifiable credentials instead
One important architectural issue is wallet loss. A soulbound token is tied to an account, so if the recipient loses access to that account, the achievement doesn't automatically follow them. ERC-5192 itself deliberately keeps the interface minimal rather than prescribing a recovery mechanism.
So, if you're building something like "Alice completed Course X → permanently issue Alice an achievement badge", I'd start with:
If you tell me what chain you're targeting (Ethereum, Base, Polygon, Arbitrum, etc.) and whether achievements need to be revocable, I can suggest the exact contract architecture and OpenZeppelin implementation.
ERC-721 standard. It overrides transfer functions to make them permanently non-transferable while adding a clear burn-authorization specification (issuer-only, receiver-only, or mutual). Because it inherits from ERC-721, it has the best out-of-the-box compatibility with existing wallets, block explorers, and NFT infrastructure. You can read more about the specification details on the EIP-5484 Proposal (or general breakdowns on Cyfrin's SBT Explainer).
