coinbase
diff --git a/‎.github/workflows/check_python.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/check_python.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/core-concepts/bazaar-discovery-layer.md‎
Lines changed: 96 additions & 70 deletions b/‎docs/core-concepts/bazaar-discovery-layer.md‎
Lines changed: 96 additions & 70 deletions
diff --git a/‎docs/core-concepts/network-and-token-support.md‎
Lines changed: 32 additions & 0 deletions b/‎docs/core-concepts/network-and-token-support.md‎
Lines changed: 32 additions & 0 deletions
@@ -23,7 +23,7 @@ jobs:
         run: uv sync --all-extras --dev
 
       - name: Run Tests
-        run: uv run python -m pytest
+        run: uv run pytest
 
   lint-python:
     runs-on: ubuntu-latest
 
@@ -89,18 +89,14 @@ Fetch the list of available x402 services using the facilitator client:
 import { HTTPFacilitatorClient } from "@x402/core/http";
 import { withBazaar } from "@x402/extensions";
 
-// Create facilitator client with Bazaar discovery extension
 const facilitatorClient = new HTTPFacilitatorClient({
   url: "https://x402.org/facilitator"
 });
 const client = withBazaar(facilitatorClient);
 
-// Fetch all available services
 const response = await client.extensions.discovery.listResources({ type: "http" });
 
-// NOTE: in an MCP context, you can see the full list then decide which service to use
-
-// Find services under $0.10
+// Filter services under $0.10
 const usdcAsset = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 const maxPrice = 100000; // $0.10 in USDC atomic units (6 decimals)
 
@@ -115,28 +111,26 @@ const affordableServices = response.items.filter(item =>
 
 {% tab title="Python" %}
 ```python
-from x402.facilitator import FacilitatorClient
-
-# Set up facilitator client (defaults to https://x402.org/facilitator)
-facilitator = FacilitatorClient()
+from x402.http import FacilitatorConfig, HTTPFacilitatorClient
 
-# Fetch all available services
-response = await facilitator.list()
+facilitator = HTTPFacilitatorClient(
+    FacilitatorConfig(url="https://api.cdp.coinbase.com/platform/v2/x402")
+)
 
-# NOTE: in an MCP context, you can see the full list then decide which service to use
+response = await facilitator.list_resources(type="http")
 
-# Find services under $0.10
+# Filter services under $0.10
 usdc_asset = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
 max_price = 100000  # $0.10 in USDC atomic units (6 decimals)
 
 affordable_services = [
-  item
-  for item in response.items
-  if any(
-    payment_req.asset == usdc_asset
-    and int(payment_req.max_amount_required) < max_price
-    for payment_req in item.accepts
-  )
+    item
+    for item in response.items
+    if any(
+        payment_req.asset == usdc_asset
+        and int(payment_req.max_amount_required) < max_price
+        for payment_req in item.accepts
+    )
 ]
 ```
 {% endtab %}
@@ -185,28 +179,40 @@ console.log("Response data:", response.data);
 
 {% tab title="Python" %}
 ```python
-from x402.client import X402Client
+import asyncio
+
 from eth_account import Account
 
-# Set up your payment account
-account = Account.from_key("0xYourPrivateKey")
-client = X402Client(account)
+from x402 import x402Client
+from x402.http.clients import x402HttpxClient
+from x402.mechanisms.evm import EthAccountSigner
+from x402.mechanisms.evm.exact.register import register_exact_evm_client
 
-# Select a service from discovery
-selected_service = affordable_services[0]
 
-# Select the payment method of your choice
-selected_payment_requirements = selected_service.accepts[0]
-input_schema = selected_payment_requirements.output_schema.input
+async def main() -> None:
+    account = Account.from_key("0xYourPrivateKey")
+    client = x402Client()
+    register_exact_evm_client(client, EthAccountSigner(account))
 
-# Make the request
-response = client.request(
-    method=input_schema.method,
-    url=input_schema.resource,
-    params={"location": "San Francisco"}  # Based on input_schema
-)
+    # Select a service from discovery (from Step 1)
+    selected_service = affordable_services[0]
+
+    # Select the payment method of your choice
+    selected_payment_requirements = selected_service.accepts[0]
+    input_schema = selected_payment_requirements.output_schema.input
+
+    # Make the request using httpx client
+    async with x402HttpxClient(client) as http:
+        response = await http.request(
+            method=input_schema.method,
+            url=input_schema.resource,
+            params={"location": "San Francisco"}  # Based on input_schema
+        )
+        await response.aread()
+        print(f"Response data: {response.json()}")
 
-print(f"Response data: {response}")
+
+asyncio.run(main())
 ```
 {% endtab %}
 {% endtabs %}
@@ -272,44 +278,64 @@ app.use(paymentMiddleware(routes, server));
 
 {% tab title="Python" %}
 ```python
-from x402.middleware.fastapi import payment_middleware
-from x402.facilitators import cdp_facilitator
-
-app.middleware("http")(
-    payment_middleware(
-        routes={
-            "/weather": {
-                "price": "$0.001",
-                "network": "eip155:8453",
-                "resource": "0xYourAddress",
-                "description": "Get current weather data for any location",
-                "extensions": {
-                    "bazaar": {
-                        "discoverable": True,
-                        "inputSchema": {
-                            "queryParams": {
-                                "location": {
-                                    "type": "string",
-                                    "description": "City name or coordinates",
-                                    "required": True
-                                }
-                            }
-                        },
-                        "outputSchema": {
-                            "type": "object",
-                            "properties": {
-                                "temperature": {"type": "number"},
-                                "conditions": {"type": "string"},
-                                "humidity": {"type": "number"}
-                            }
+from fastapi import FastAPI
+
+from x402.http import FacilitatorConfig, HTTPFacilitatorClient, PaymentOption
+from x402.http.middleware.fastapi import PaymentMiddlewareASGI
+from x402.http.types import RouteConfig
+from x402.mechanisms.evm.exact import ExactEvmServerScheme
+from x402.server import x402ResourceServer
+
+app = FastAPI()
+
+# Create facilitator client (CDP mainnet)
+facilitator = HTTPFacilitatorClient(
+    FacilitatorConfig(url="https://api.cdp.coinbase.com/platform/v2/x402")
+)
+
+# Create resource server and register EVM scheme
+server = x402ResourceServer(facilitator)
+server.register("eip155:8453", ExactEvmServerScheme())
+
+# Define routes with Bazaar discovery metadata
+routes: dict[str, RouteConfig] = {
+    "GET /weather": RouteConfig(
+        accepts=[
+            PaymentOption(
+                scheme="exact",
+                pay_to="0xYourAddress",
+                price="$0.001",
+                network="eip155:8453",
+            ),
+        ],
+        mime_type="application/json",
+        description="Get current weather data for any location",
+        extensions={
+            "bazaar": {
+                "discoverable": True,
+                "inputSchema": {
+                    "queryParams": {
+                        "location": {
+                            "type": "string",
+                            "description": "City name or coordinates",
+                            "required": True,
                         }
                     }
-                }
+                },
+                "outputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "temperature": {"type": "number"},
+                        "conditions": {"type": "string"},
+                        "humidity": {"type": "number"},
+                    },
+                },
             }
         },
-        facilitator=cdp_facilitator
-    )
-)
+    ),
+}
+
+app.add_middleware(PaymentMiddlewareASGI, routes=routes, server=server)
 ```
 {% endtab %}
 
 
@@ -192,6 +192,38 @@ schemes := []ginmw.SchemeConfig{
 }
 ```
 {% endtab %}
+
+{% tab title="Python" %}
+```python
+from x402.http import FacilitatorConfig, HTTPFacilitatorClient, PaymentOption
+from x402.http.types import RouteConfig
+from x402.mechanisms.evm.exact import ExactEvmServerScheme
+from x402.server import x402ResourceServer
+
+# Create facilitator client for your network
+facilitator = HTTPFacilitatorClient(
+    FacilitatorConfig(url="https://your-facilitator.com")
+)
+
+# Create server and register EVM scheme for your network
+server = x402ResourceServer(facilitator)
+server.register("eip155:43114", ExactEvmServerScheme())  # Avalanche mainnet
+
+# Now use any CAIP-2 network identifier in your routes:
+routes: dict[str, RouteConfig] = {
+    "GET /api/data": RouteConfig(
+        accepts=[
+            PaymentOption(
+                scheme="exact",
+                price="$0.001",
+                network="eip155:43114",  # Avalanche mainnet
+                pay_to="0xYourAddress",
+            ),
+        ],
+    ),
+}
+```
+{% endtab %}
 {% endtabs %}
 
 **Key Points:**