# Client \[Handle 402 responses automatically] Handle `402` Payment Required responses automatically. ## Quick start ```python [client.py] from mpp.client import Client from mpp.methods.tempo import tempo, TempoAccount, ChargeIntent account = TempoAccount.from_key("0x...") async with Client(methods=[tempo(account=account, intents={"charge": ChargeIntent()})]) as client: response = await client.get("https://api.example.com/resource") print(response.json()) ``` ## Common methods | Method | Description | |--------|-------------| | `delete(url, **kwargs)` | DELETE request with payment handling | | `get(url, **kwargs)` | GET request with payment handling | | `post(url, **kwargs)` | POST request with payment handling | | `put(url, **kwargs)` | PUT request with payment handling | | `request(method, url, **kwargs)` | Generic request | ## One-off requests ```python [client.py] from mpp.client import get from mpp.methods.tempo import tempo, TempoAccount, ChargeIntent response = await get( "https://api.example.com/resource", methods=[tempo(account=TempoAccount.from_key("0x..."), intents={"charge": ChargeIntent()})], ) ``` ## Payment sessions For payment session channels, use `StreamMethod` instead of `tempo()`. The client opens a payment channel and sends incremental vouchers as it consumes content: ```python [stream.py] import httpx from mpp.client import PaymentTransport from mpp.methods.tempo import StreamMethod, TempoAccount account = TempoAccount.from_key("0x...") method = StreamMethod( account=account, currency="0x20c0000000000000000000000000000000000000", deposit=10_000_000, ) transport = PaymentTransport(methods=[method]) async with httpx.AsyncClient(transport=transport, timeout=60.0) as client: async with client.stream("GET", "https://api.example.com/chat", params={"prompt": "Explain payment channels"}, ) as response: async for line in response.aiter_lines(): if line.startswith("data: "): print(line[6:], end="", flush=True) ``` `StreamMethod` auto-manages the channel lifecycle—opening the channel on the first request and sending cumulative vouchers on subsequent requests to the same server. ## Custom httpx transport `PaymentTransport` wraps any `httpx.AsyncBaseTransport`, so you can compose it with custom transports: ```python [transport.py] import httpx from mpp.client import PaymentTransport from mpp.methods.tempo import tempo, TempoAccount, ChargeIntent account = TempoAccount.from_key("0x...") transport = PaymentTransport( methods=[tempo(account=account, intents={"charge": ChargeIntent()})], inner=httpx.AsyncHTTPTransport(retries=3), ) async with httpx.AsyncClient(transport=transport) as client: response = await client.get("https://api.example.com/resource") ``` For manual Challenge/Credential handling, see [Core types](/sdk/python/core).