ERC-721 defines a set of contract interfaces and behaviors for tracking individually identifiable tokens, including ownership queries, authorized transfers, approvals, and related events. Its core interface does not require every optional feature, such as metadata or token enumeration, and compliance alone does not establish the safety, rights, or availability of anything associated with a token.
What the ERC-721 specification is for
An interface is a defined way for applications and contracts to request information or actions from a contract. ERC-721 standardizes interface behavior for tokens identified individually within a contract. A token identifier is therefore not a global identifier by itself: identifying a token requires the contract address together with its token ID on the relevant Ethereum chain.
The distinction matters when an application displays or processes a token. A familiar collection name, symbol, or image is not a substitute for the contract address and token ID. Applications need to use the contract’s interface and identify the particular token they mean. The standard describes token-level interactions; it does not define every rule an application, marketplace, issuer, or off-chain service might add.
Core ERC-721 interface and token ownership
The core ownership queries answer different questions. ownerOf(tokenId) returns the address recorded as owner of a particular token. balanceOf(owner) returns how many tokens the contract records for an address. That balance is a count of individually identified tokens, not a fungible-token amount that can be divided into interchangeable units.
ERC-721 also defines events that let applications observe relevant token activity. The Transfer event records a token transfer, including its token ID and the addresses involved; minting and burning are represented through transfers to or from the zero address. The Approval event reports approval for a specific token, and ApprovalForAll reports an operator authorization associated with an owner. Events help applications track contract activity, but an application must still interpret them in the context of the correct contract and chain.
These are interface-level behaviors. A contract’s address and token ID identify the token under the standard; a display label or metadata reference does not replace that identifier. The ERC-721 interface standardizes owner lookup, approvals, transfer behavior, and transfer events for distinct tokens.
How ERC-721 transfers and approvals work
An owner can transfer a token directly. Alternatively, another address can transfer it if the owner has authorized that address. ERC-721 distinguishes approval for one token from approval for an operator to act across the owner’s tokens. The first is limited to the identified token; the second applies as an operator authorization for that owner.
A caller or application should distinguish these permissions before initiating a transfer. Having an address or knowing a token ID does not itself establish permission to transfer. The contract’s approval and transfer behavior determines whether the requested action is authorized.
The standard also includes safe-transfer functions. At a high level, these functions add a receiver check when the destination is a contract: the receiving contract must accept the transfer through the expected callback behavior. This check is intended to avoid sending a token to a contract that does not indicate it can receive ERC-721 tokens. It does not establish that the recipient contract will provide any particular service or preserve access to associated content.
The transfer and approval events allow applications to process changes, but they are not a substitute for calling the correct contract or validating the token identifier. Where an application uses a contract ABI—the encoding rules for function selectors, arguments, return values, errors, and events—it must match that ABI to the deployed contract interface and network address.
Optional metadata and enumeration extensions
Metadata is an optional extension, not a requirement of the core ownership and transfer interface. A contract supporting the metadata extension can expose a token URI for a particular token ID. The URI refers to metadata; it does not, by itself, guarantee that the referenced data will remain available, be accurate, or describe content under any particular terms. An application should treat the URI as a reference and distinguish it from the ownership record.
Enumeration is another optional extension. It adds a way to list tokens associated with the contract or an owner. Because enumeration is not required by the core interface, applications should not assume that every ERC-721 contract can provide a complete token list through standardized enumeration functions. They should check whether the specific contract supports the extension they need.
These extensions serve different purposes: metadata supplies a reference to token-specific information, while enumeration supplies token-listing operations. Neither changes the need to identify a token through its contract address and token ID.
What ERC-721 compliance does—and does not—establish
For a concrete implementation, verify which ERC-721 interfaces the contract supports and compare the relevant functions and events with the specification. Do not infer optional metadata or enumeration support from the presence of core transfer functions. An application also needs an ABI that matches the deployed contract and network address; otherwise, its calls and event decoding may not correspond to the intended interface.
Compliance is not a general assurance about the contract or the things it references. The ERC-721 interface does not prove that contract code is bug-free, that a token holder has copyright or physical title, or that off-chain content will remain available. Token ownership is recorded by associating a token identifier with an address, but ownership of that record does not automatically transfer copyright, physical title, or every off-chain right.
Marketplace compatibility is also not established merely by saying a contract is ERC-721 compliant. Applications and marketplaces depend on their own integrations and on the particular contract behavior and supported interfaces. For technical review, keep the checks narrow: identify the deployed contract and token ID, confirm the functions and events the implementation supports, establish whether optional extensions are present, and treat metadata and external rights as separate questions.