The Ethereum Name Service (ENS) revolutionizes how users interact with blockchain addresses by replacing complex hexadecimal strings with easy-to-remember, human-friendly names. Much like the Domain Name System (DNS) translates google.com into an IP address, ENS maps readable names such as alice.eth to wallet addresses, content hashes, and other resources on the decentralized web.
For developers working with Python and blockchain applications, integrating ENS into projects enhances usability and reduces user errors caused by incorrect address inputs. Built directly into web3.py, one of the most popular Ethereum development libraries, the ens module provides a seamless interface for domain lookups, address resolution, metadata management, and more.
This guide explores the full capabilities of ENS within web3.py, from setup to advanced features like multichain resolution and text records—all while maintaining clean, secure, and scalable code practices.
Setting Up the ENS Module in web3.py
To begin using ENS in your Python environment, you first need to instantiate an ENS object. There are three primary methods to achieve this:
1. Automatic Detection
Use the built-in auto-import feature for quick initialization:
from ens.auto import nsThis automatically detects your provider and configures the ENS instance accordingly.
2. Using a Provider
Manually specify a provider such as IPC, HTTP, or Websocket:
from web3 import IPCProvider
from ens import ENS
provider = IPCProvider('/path/to/geth.ipc')
ns = ENS(provider)3. From an Existing Web3 Instance
Leverage an existing Web3 object to inherit middleware, provider settings, and configuration flags:
from ens import ENS
from web3 import Web3
w3 = Web3(IPCProvider('/path/to/geth.ipc'))
ns = ENS.from_web3(w3)👉 Discover how blockchain developers streamline address management using smart tools.
For asynchronous applications, use the AsyncENS class:
from ens import AsyncENS
ns = AsyncENS(provider)Note: When accessing w3.ens, web3.py automatically creates an ENS instance linked to that Web3 object, ensuring consistent state across modules.
Managing Strict Bytes Type Checking
The ENS instance inherits the strict_bytes_type_checking flag from its parent Web3 instance. This setting controls whether byte-encoded data must be properly padded.
w3.strict_bytes_type_checking = False
ns = ENS.from_web3(w3)
assert ns.strict_bytes_type_checking is FalseDisabling strict checking allows for more flexible encoding but should be used cautiously in production environments.
Core ENS Functionality for Developers
Resolving Names to Addresses
One of the most common uses of ENS is translating a domain name into a blockchain address:
eth_address = ns.address('ethereum.eth')This returns the Ethereum address associated with ethereum.eth. If no Top-Level Domain (TLD) is specified, ENS will not infer it—always include .eth or another valid suffix.
Multichain Address Resolution
With ENSIP-9, ENS supports resolving addresses across multiple blockchains using coin type identifiers from SLIP-44. For example, retrieve a Bitcoin address linked to an ENS name:
btc_address = ns.address('user.eth', coin_type=0) # Bitcoin uses coin_type 0Ethereum uses coin_type=60, making cross-chain identity management both possible and intuitive.
Reverse Resolution: Finding Names from Addresses
You can also perform reverse lookups—determining which ENS name points to a given address:
domain = ns.name('0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7')ENS verifies forward resolution during this process to ensure accuracy—only if the name resolves back to the queried address is the result considered valid. This prevents spoofing and strengthens trust in reverse records.
Managing Ownership and Records
Checking Domain Ownership
Verify ownership of any ENS domain:
owner = ns.owner('exchange.eth')This returns the Ethereum address currently registered as the owner of the domain.
Linking a Name to an Address
Set up forward resolution so that a name resolves to a specific address:
ns.setup_address('myname.eth', '0xYourWalletAddress')If the address matches the owner’s wallet, you can omit it:
ns.setup_address('myname.eth') # Automatically uses owner's addressSubdomains at any depth can also be claimed:
ns.setup_address('sub.deep.domain.myname.eth')⚠️ Warning: Gas costs increase with subdomain depth due to additional hashing operations.
Multichain Address Setup
Just like resolution, you can configure multichain addresses:
ns.setup_address('myname.eth', coin_type=60) # Set Ethereum addressSetting Reverse Resolution (Caller ID for Wallets)
Enable reverse resolution so others can discover your ENS name when interacting with your address:
ns.setup_name('myname.eth')This sets up the reverse record via the ENS Reverse Resolver. If the forward record doesn’t exist yet, setup_name() will create it automatically.
👉 See how top Web3 apps simplify user identity with decentralized naming systems.
Storing and Retrieving Metadata with Text Records
As a domain owner, you can attach public metadata to your ENS name using text records. These are useful for storing profile information, URLs, social media links, avatars, and more.
Setting Text Metadata
ns.set_text('myname.eth', 'url', 'https://example.com')
ns.set_text('myname.eth', 'com.twitter', 'myhandle')
ns.set_text('myname.eth', 'email', '[email protected]')A custom transaction dictionary can be passed for advanced control:
tx_dict = {'from': '0xYourAddress', 'gas': 200000}
ns.set_text('myname.eth', 'description', 'Blockchain developer', tx_dict)Reading Public Text Records
Anyone can query public metadata:
website = ns.get_text('myname.eth', 'url')
twitter = ns.get_text('myname.eth', 'com.twitter')A full list of standardized keys is available in the ENS documentation.
Working with Resolvers
Every ENS name uses a resolver contract to translate names into addresses and other data. You can retrieve the resolver for any name:
resolver = ns.resolver('myname.eth')
print(resolver.address) # Outputs resolver contract addressResolvers implementing the ExtendedResolver interface (defined in ENSIP-10) support wildcard subdomain resolution, enabling dynamic routing of subdomains without pre-registration.
Frequently Asked Questions (FAQ)
Q: What is the main benefit of using ENS over raw addresses?
A: ENS improves user experience by replacing hard-to-read hexadecimal addresses with memorable names like alice.eth, reducing errors in transactions and improving accessibility in dApps.
Q: Can I use ENS for non-Ethereum blockchains?
A: Yes! Thanks to ENSIP-9, ENS supports multichain address resolution for over 20 blockchains including Bitcoin, Polygon, and Solana via SLIP-44 coin types.
Q: Do I own my ENS domain forever after registration?
A: No. ENS domains require annual renewal in ETH to maintain ownership. Failure to renew results in loss of control after expiration.
Q: Is reverse resolution secure?
A: Yes. The system checks forward resolution to confirm alignment between name and address, preventing unauthorized claims.
Q: Can I set custom metadata not listed in standards?
A: While only standardized keys are widely supported, technically any key-value pair can be stored. However, dApps may ignore unrecognized fields.
Q: How does gas cost scale when setting up deep subdomains?
A: Each additional subdomain level increases hashing complexity and gas usage. Deep hierarchies should be used judiciously.
Final Thoughts
Integrating Ethereum Name Service into your web3.py applications significantly enhances user interaction by abstracting away complex cryptographic addresses. From simple lookups to rich metadata storage and cross-chain identity management, ENS empowers developers to build more intuitive and user-centric decentralized applications.
Whether you're building a wallet, NFT marketplace, or social dApp, leveraging ENS ensures cleaner interfaces and fewer user errors—critical components of mainstream Web3 adoption.
👉 Start building smarter dApps today with modern identity solutions.
Keywords: Ethereum Name Service, ENS, web3.py, blockchain addresses, decentralized identity, smart contracts, multichain resolution, text records