Python

Python gives you two strong entry points to Arbitrum One. web3.py is the general-purpose client for scripting, backend services, and data pipelines, while eth-brownie wraps it in a framework built for smart-contract development, testing, and deployment. Both connect to the EVM-equivalent Nitro rollup at https://arbitrum.therpc.io/YOUR_API_KEY, and together they cover everything from a quick one-off balance script to a complex production application interacting with Arbitrum DeFi like Aave or GMX.

web3.py 6+ ships both synchronous and asynchronous interfaces. Synchronous code is fine for scripts and simple jobs against Arbitrum One; for concurrent workloads, switch to AsyncWeb3 paired with an async-compatible provider so many RPC calls run in flight at once rather than one after another.

Web3.py

Install with pip install web3, then instantiate the client by wrapping the Arbitrum One endpoint in an HTTP provider: Web3(Web3.HTTPProvider('https://arbitrum.therpc.io/YOUR_API_KEY')). web3.py is the de facto official Python library for Ethereum-compatible chains and exposes the full JSON-RPC API surface, so every method Arbitrum One supports — get_balance, get_block, send_raw_transaction, and the rest — is available directly.

1from web3 import Web3
2from eth_account import Account
3import json
4 
5# Initialize web3
6web3 = Web3(Web3.HTTPProvider('https://arbitrum.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 for Arbitrum One: the full JSON-RPC API, both synchronous and async interfaces, comprehensive type hints, a middleware system, and ENS support.

Eth-brownie

eth-brownie is a Python framework focused on the smart-contract lifecycle — writing, compiling, testing, and deploying Solidity — and it works against Arbitrum One once you register the network in its config. Install it with pip install eth-brownie. It is the right tool when you are building and shipping your own contracts to the rollup rather than just calling existing ones.

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 for Arbitrum One development: a contract testing framework, deployment management, an interactive console, network management for adding the rollup, and a Python REPL for live debugging.

Async Support

The async interface centers on AsyncWeb3, which delivers far better throughput when you fire many Arbitrum One calls concurrently — for instance backfilling a range of blocks or polling several addresses at once. It requires an async-compatible provider and an asyncio event loop to drive the coroutines, as in the block-fetching example below.

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 import TxParams, Wei, and Address from web3.types to annotate your Arbitrum One code. Typed signatures unlock IDE autocompletion and let mypy catch mistakes statically — for example flagging a plain int passed where a Wei value is expected before it ever reaches the network and risks a malformed transaction.

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    }