Ethereum

Ethereum

Python

Python's Ethereum stack splits along two jobs. web3.py is the general-purpose client — what you import to query a balance, watch logs, or sign a transaction against chain 1 from a script, a Django backend, or a data pipeline. eth-brownie sits one level up, a development framework built on web3.py for writing, testing, and deploying Solidity contracts with pytest-style assertions. The same library that backs a five-line block-explorer script also powers a production indexer, so you rarely outgrow it.

From version 6 on, web3.py offers both a synchronous and an async interface to Ethereum. The sync Web3 is fine for scripts and request-scoped backend work. When you need to fan out many calls at once, switch to AsyncWeb3 paired with an async provider so the calls run concurrently on an asyncio loop instead of blocking one after another.

Web3.py

web3.py is the official Python Ethereum library, and it mirrors the full JSON-RPC surface — block reads, balances, transactions, contract calls, filters. Install it with pip install web3, then wrap the endpoint in an HTTP provider: Web3(Web3.HTTPProvider('https://ethereum.therpc.io/YOUR_API_KEY')). web3.eth.get_balance returns wei as a Python int, and web3.from_wei(..., 'ether') scales it to a Decimal ETH value, so you keep full precision instead of risking float drift on 18-decimal numbers.

1from web3 import Web3
2from eth_account import Account
3import json
4 
5# Initialize web3
6web3 = Web3(Web3.HTTPProvider('https://ethereum.therpc.io/YOUR_API_KEY'))
7 
8# Get balance
9def get_balance(address):
10    balance_wei = web3.eth.get_balance(address)
11    balance_eth = web3.from_wei(balance_wei, 'ether')
12    return balance_eth
13 
14# Send transaction
15def send_transaction(private_key, to_address, value_eth):
16    account = Account.from_key(private_key)
17    transaction = {
18        'nonce': web3.eth.get_transaction_count(account.address),
19        'to': to_address,
20        'value': web3.to_wei(value_eth, 'ether'),
21        'gas': 21000,
22        'gasPrice': web3.eth.gas_price
23    }
24    signed_txn = account.sign_transaction(transaction)
25    tx_hash = web3.eth.send_raw_transaction(signed_txn.rawTransaction)
26    return web3.eth.wait_for_transaction_receipt(tx_hash)

• GitHub: https://github.com/ethereum/web3.py
• Docs: https://web3py.readthedocs.io/
• Full Ethereum JSON-RPC API coverage
• Both synchronous and AsyncWeb3 interfaces
• Type hints throughout for IDE and mypy support
• A middleware stack you can hook for retries, caching, or signing
• ENS resolution for .eth names

Eth-brownie

eth-brownie is a Python framework aimed squarely at the contract side of Ethereum: compiling Solidity, writing pytest tests against a forked or local chain, and managing deployments across networks. Install it with pip install eth-brownie. It pulls in its own compiler management and an interactive console, so MyContract.deploy(...) and MyContract.at(address) feel like ordinary Python objects while Brownie handles the transaction signing and receipt waiting underneath.

1from brownie import *
2 
3# Deploy contract
4def deploy_contract():
5    account = accounts[0]
6    return MyContract.deploy({'from': account})
7 
8# Interact with contract
9def interact_with_contract(contract_address):
10    contract = MyContract.at(contract_address)
11    return contract.myFunction({'from': accounts[0]})
12 
13# Test contract
14def test_contract(Contract):
15    account = accounts[0]
16    contract = account.deploy(Contract)
17    assert contract.myFunction() == expected_value

• GitHub: https://github.com/eth-brownie/brownie
• Docs: https://eth-brownie.readthedocs.io/
• A pytest-based testing framework for Ethereum contracts
• Deployment management with tracked, repeatable scripts
• An interactive console for poking at live contracts
• Network configuration for mainnet, testnets, and local forks
• A full Python REPL with your contracts already in scope

Async Support

When you need to pull many things from Ethereum at once — say, the last several blocks, or balances for a list of addresses — the async interface pays off. AsyncWeb3 over an async provider lets those calls overlap on an asyncio event loop instead of waiting in line, so the wall-clock time is set by the slowest round-trip rather than the sum of all of them. Each method becomes awaitable: await w3.eth.get_block_number(), and you drive the whole thing from asyncio.run(...).

1from web3.auto import w3
2import asyncio
3 
4async def get_latest_blocks(count):
5    latest = await w3.eth.get_block_number()
6    blocks = []
7    for i in range(count):
8        block = await w3.eth.get_block(latest - i)
9        blocks.append(block)
10    return blocks
11 
12# Usage
13blocks = asyncio.run(get_latest_blocks(10))

Type Hints

web3.py ships real type stubs, so Ethereum primitives have names you can lean on: Wei for amounts, Address for checksummed addresses, TxParams for the transaction dict. Annotating a function that builds a transaction with these — as below — gives you editor autocompletion and lets mypy catch a swapped argument or a missing field before the code ever reaches mainnet. It's the difference between a type error at your desk and a reverted transaction that still cost gas.

1from web3.types import TxParams, Wei, Address
2from typing import Optional
3 
4def prepare_transaction(
5    to: Address,
6    value: Wei,
7    gas_price: Optional[Wei] = None
8) -> TxParams:
9    return {
10        'to': to,
11        'value': value,
12        'gasPrice': gas_price or web3.eth.gas_price
13    }