Python SDK

pip install t402

from fastapi import FastAPI
from t402.fastapi.middleware import require_payment
 
app = FastAPI()
 
app.middleware("http")(
    require_payment(
        price="0.01",
        pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C"
    )
)
 
@app.get("/")
async def root():
    return {"message": "Premium content!"}

from eth_account import Account
from t402.clients.httpx import t402HttpxClient
 
account = Account.from_key("your_private_key")
 
async with t402HttpxClient(account=account) as client:
    response = await client.get("https://api.example.com/protected")
    print(await response.aread())

from fastapi import FastAPI
from t402.fastapi.middleware import require_payment
 
app = FastAPI()
 
# Protect all routes
app.middleware("http")(
    require_payment(
        price="0.01",
        pay_to_address="0x..."
    )
)
 
# Protect specific routes
app.middleware("http")(
    require_payment(
        price="0.001",
        pay_to_address="0x...",
        path=["/api/premium", "/api/exclusive"]
    )
)

from flask import Flask
from t402.flask.middleware import PaymentMiddleware
 
app = Flask(__name__)
payment = PaymentMiddleware(app)
 
# Protect all routes
payment.add(
    price="$0.01",
    pay_to_address="0x..."
)
 
# Protect specific routes
payment.add(
    path="/api/premium",
    price="$0.001",
    pay_to_address="0x..."
)

from eth_account import Account
from t402.clients.httpx import t402HttpxClient
 
account = Account.from_key("0x...")
 
async with t402HttpxClient(account=account) as client:
    response = await client.get("https://api.example.com/protected")

from eth_account import Account
from t402.clients.requests import t402_requests
 
account = Account.from_key("0x...")
session = t402_requests(account)
 
response = session.get("https://api.example.com/protected")

from t402 import (
    TON_MAINNET,
    TON_TESTNET,
    validate_ton_address,
    get_ton_network_config,
)
 
config = get_ton_network_config(TON_MAINNET)
is_valid = validate_ton_address("EQD...")

from t402 import (
    TRON_MAINNET,
    TRON_NILE,
    validate_tron_address,
    get_tron_network_config,
)
 
config = get_tron_network_config(TRON_MAINNET)
is_valid = validate_tron_address("T...")

from t402 import (
    create_bundler_client,
    create_paymaster,
    create_smart_account,
    SafeAccountConfig,
)
 
# Create bundler
bundler = create_bundler_client(
    bundler_type="pimlico",
    api_key="your_api_key",
    chain_id=8453
)
 
# Create paymaster for sponsored txs
paymaster = create_paymaster(
    paymaster_type="pimlico",
    api_key="your_api_key",
    chain_id=8453
)
 
# Create Safe smart account
account = create_smart_account(
    config=SafeAccountConfig(
        owner_private_key="0x...",
        chain_id=8453,
    ),
    bundler=bundler,
    paymaster=paymaster,
)

from t402 import create_usdt0_bridge, get_bridgeable_chains
 
# Check supported chains
chains = get_bridgeable_chains()
 
# Create bridge client
bridge = create_usdt0_bridge(
    private_key="0x...",
    source_chain_id=1,  # Ethereum
)
 
# Bridge USDT0
result = await bridge.bridge(
    destination_chain_id=8453,  # Base
    amount="1000000",  # 1 USDT0
    recipient="0x...",
)

from t402 import WDKSigner, generate_seed_phrase, WDKConfig
 
# Generate wallet
seed = generate_seed_phrase()
 
# Create signer
signer = WDKSigner(config=WDKConfig(seed_phrase=seed))
 
# Sign payment
signature = await signer.sign_payment(
    chain_id=8453,
    amount="1000000",
    recipient="0x...",
)