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.
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 (or general breakdowns on Cyfrin's SBT Explainer).[](]()](]()]()
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:
For a non-transferable token representing a unique achievement, the best and most widely adopted standard is ERC-5192 (Minimal Soulbound NFTs).[](]()]()
For an achievement token that must not be transferable, the most straightforward choice on an EVM chain is ERC-721 + ERC-5192 (Minimal Soulbound NFTs).
Why ERC-5192
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 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 non-fungible token framework.[](]()]()
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.[](]()]()
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 and provides a standard interface so wallets and applications can detect that the token is permanently/non-transferably bound to an account.
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.
Sources AI cites
35% of citations to these sources link to brands' own websites.
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.[](https://eips.ethereum.org/EIPS/eip-4973)
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.
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.
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.[](https://eips.ethereum.org/EIPS/eip-5192)
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.[](https://eips.ethereum.org/EIPS/eip-5727)
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
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.
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:[](https://eips.ethereum.org/EIPS/eip-5484)
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.[](https://ethereum-magicians.org/t/erc-idea-address-derived-non-transferable-token-soulbound-token/28475)
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.[](https://www.cyfrin.io/blog/what-is-a-soulbound-token)
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.
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.
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.[](https://ethereum-magicians.org/t/eip-4973-account-bound-tokens/8825?page=8)
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.
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.
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:[](https://www.cyfrin.io/blog/what-is-a-soulbound-token)
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.
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.[](https://eips.ethereum.org/EIPS/eip-5484)
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.
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?
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.
