Python

Python's tooling covers the full range of Base work. web3.py is the general-purpose library for scripting and application backends — reading balances, sending transactions, and calling contracts on the Coinbase-built L2 — while eth-brownie wraps a complete smart-contract development workflow with testing and deployment built in. Because Base is EVM-equivalent and uses ETH for gas, both connect to https://base.therpc.io/YOUR_API_KEY at chain ID 8453, and the same code scales from a one-off script to a production indexer.

web3.py 6+ offers both synchronous and asynchronous interfaces against Base. The sync API is simplest for scripts; for concurrent workloads, async usage requires AsyncWeb3 paired with an async-compatible provider so many Base requests can be in flight at once.

Web3.py

Install web3.py with pip install web3, then connect by wrapping your Base endpoint in an HTTP provider: Web3(Web3.HTTPProvider('https://base.therpc.io/YOUR_API_KEY')). As the de facto official Python library for EVM chains, it exposes the full JSON-RPC surface — eth.get_balance, eth.send_raw_transaction, contract calls, and more — all working unchanged on Base at chain ID 8453.

1from web3 import Web3
2from eth_account import Account
3import json
4 
5# Initialize web3
6web3 = Web3(Web3.HTTPProvider('https://base.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/
• Key features: full Base JSON-RPC coverage, both sync and async interfaces, comprehensive type hints, a middleware system, and ENS support

Eth-brownie

eth-brownie is a Python framework built around the full smart-contract lifecycle on Base — writing, testing, and deploying Solidity — with pytest-style tests and managed deployments. Configure a Base network in Brownie pointing at https://base.therpc.io/YOUR_API_KEY (chain ID 8453) and your contracts deploy there just as they would on any EVM chain. Install it with pip install eth-brownie.

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/
• Key features: a contract testing framework, deployment management, an interactive console for Base, network configuration, and a Python REPL for live debugging

Async Support

For concurrent work against Base — fetching many blocks or balances at once — web3.py's AsyncWeb3 interface lets requests overlap instead of running one at a time, a real win when you're scanning Base's fast ~2s blocks. It requires an async-compatible provider and runs inside an asyncio event loop, so drive it from async def functions with 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 comprehensive type stubs, so you can annotate your Base code with TxParams, Wei, and Address imported from web3.types. These give you IDE autocompletion and let mypy statically catch mistakes — like passing a plain int where a Wei is expected — before a transaction ever reaches the Base network.

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    }