Python

Python has a mature toolset for building on Polygon. For general scripting and application code, web3.py is the standard library — and because Polygon PoS is EVM-equivalent, the same web3.py API you would use against Ethereum works directly against https://polygon.therpc.io/YOUR_API_KEY. For contract-heavy workflows — compiling, testing, and deploying Solidity — eth-brownie wraps web3.py in a development framework. Together they cover everything from a throwaway balance-checking script to a complex production service running on chain ID 137.

web3.py 6+ ships both synchronous and asynchronous interfaces, so you can choose whichever fits your Polygon workload. The async path requires AsyncWeb3 together with an async-compatible provider, which lets you fan out many concurrent calls to chain 137 without blocking a thread per request.

Web3.py

Install with pip install web3, then connect by wrapping the Polygon endpoint in an HTTP provider: Web3(Web3.HTTPProvider('https://polygon.therpc.io/YOUR_API_KEY')). web3.py is the de facto standard Python library for EVM chains and exposes the full Polygon API surface — balances, transactions, contracts, logs, and more — so anything available over JSON-RPC on chain 137 is reachable from Python.

1from web3 import Web3
2from eth_account import Account
3import json
4 
5# Initialize web3
6web3 = Web3(Web3.HTTPProvider('https://polygon.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 Polygon JSON-RPC coverage, both sync and async interfaces, type hints, a configurable middleware stack, and ENS resolution

Eth-brownie

eth-brownie is a Python framework built for smart-contract development on EVM chains like Polygon — it handles compiling Solidity, running test suites, and managing deployments to chain 137, with an interactive console for poking at contracts live. 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, network configuration for adding Polygon, and a full Python REPL for live experimentation

Async Support

For concurrent workloads against Polygon — say, fetching many blocks or balances at once — web3.py's async interface built on AsyncWeb3 is far more efficient than firing sequential blocking calls. It needs an async-compatible provider and runs inside an asyncio event loop (via asyncio.run(...)), so multiple requests to chain 137 can be in flight at the same time instead of waiting on each other.

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 Polygon code with TxParams, Wei, and Address imported from web3.types. These annotations give you IDE autocompletion and let mypy statically verify that, for example, you are passing a proper Wei amount to a transaction on chain 137 rather than a bare integer that silently means the wrong thing.

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    }