讓你的 AI Agent 透過 x402 + AgenticTrade 自動支付 API 費用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

1. AGENT DISCOVERS a service via MCP (Model Context Protocol)
       ↓
2. AGENT CHECKS its prepaid balance on AgenticTrade
       ↓
3. AGENT SENDS request with x402 payment headers
       ↓
4. AGENTICTRADE PROXY intercepts, verifies funds, deducts, forwards
       ↓
5. SERVICE executes and returns result
       ↓
6. AGENTICTRADE records usage, updates reputation, settles provider

1

pip install agentictrade-python

1
2
3
4
5
6
7

from agentictrade import AgenticTradeClient

# Initialize with your agent's API key (get this from agentictrade.io/dashboard)
client = AgenticTradeClient(
    api_key="acp_your_agent_proxy_key",  # Buyer proxy key
    agent_id="agent_abc123"               # Your agent's registered ID
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Search for services that match your agent's needs
services = client.discover(
    category="data",
    tags=["crypto", "sentiment", "nlp"],
    max_price=0.05,  # Max price per call in USD
    min_reputation=0.8  # Only use services with 80%+ reputation score
)

print(f"Found {len(services)} matching services:")
for svc in services:
    print(f"  - {svc.name}: ${svc.price_per_call}/call (reputation: {svc.reputation})")

# Select the best match
selected = services[0]
print(f"Using: {selected.name}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# The magic: payment happens automatically in the proxy layer
# Your agent doesn't handle money — it just calls the method

result = client.call(
    service_id=selected.id,
    endpoint="/sentiment",
    params={"symbol": "BTC", "timeframe": "24h"}
)

# That's it. The x402 headers are injected, funds are verified,
# the call is proxied, and you get your result.

print(f"Sentiment score for BTC: {result.sentiment_score}")
print(f"Confidence: {result.confidence}")
print(f"Cost: ${result.metadata.amount_charged} (deducted automatically)")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Check your agent's prepaid balance
balance = client.get_balance()
print(f"Balance: ${balance.available} USDC")
print(f"Pending: ${balance.pending}")

# Top up if needed (via NOWPayments crypto checkout)
if balance.available < 1.00:
    checkout_url = client.create_topup_url(amount=50, currency="USDC")
    print(f"Top up at: {checkout_url}")
    # In production: your agent monitors this and self-funds when low

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

from agentictrade import AgenticTradeClient

client = AgenticTradeClient(api_key="acp_your_agent_key")

def agent_task(task_description: str):
    """
    Your agent decides what it needs, discovers the right service,
    and pays for it — all autonomously.
    """

    # Step 1: Parse what tools the task requires
    required_capabilities = parse_capabilities(task_description)
    # e.g., ["sentiment_analysis", "price_data", "news_scraping"]

    results = {}

    for capability in required_capabilities:
        # Step 2: Auto-discover best service for this capability
        services = client.discover(
            capability=capability,
            max_price=0.10,
            min_reputation=0.7
        )

        if not services:
            print(f"⚠️ No service found for: {capability}")
            continue

        # Step 3: Select highest-reputation, lowest-cost option
        best = min(services, key=lambda s: (-s.reputation, s.price_per_call))

        # Step 4: Execute — payment happens automatically via x402
        result = client.call(best.id, params=build_params(task_description, capability))

        # Step 5: Log the transaction for audit
        client.log_transaction(
            service_id=best.id,
            capability=capability,
            cost=result.metadata.amount_charged,
            quality_score=result.metadata.latency_ms
        )

        results[capability] = result.data

    return results

# Example usage
task = "Analyze Bitcoin sentiment from social media and cross-reference with BTC price data"
outputs = agent_task(task)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

1. Receives: POST /api/v1/proxy/{service_id}/sentiment
   Headers:
     Authorization: Bearer acp_your_key
     Content-Type: application/json
     X-Payment-Auth-Type: x402
     X-Payment-Max-Amount: 0.05  (max you're willing to pay)

2. Verifies your prepaid balance > $0.05

3. Forwards request to service provider's real endpoint

4. On response: calculates final amount, deducts from your balance,
   credits provider's account, records usage metadata

5. Returns: your data + billing headers:
   X-ACF-Amount: 0.012
   X-ACF-Currency: USDC
   X-ACF-Provider: svc_4a8f2c1d9e3b
   X-ACF-Latency-Ms: 34
   X-ACF-Rate-Limit-Remaining: 287

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Get your agent's transaction history
transactions = client.get_transactions(
    limit=100,
    service_id="svc_4a8f2c1d9e3b"  # Optional filter
)

for tx in transactions:
    print(f"{tx.timestamp}: {tx.endpoint} → ${tx.amount} ({tx.latency_ms}ms)")

# Get aggregated spending by service
spending = client.get_spending_report(period="30d")
print(spending)
# {
#   "total_spent": 847.32,
#   "by_service": {
#     "Crypto Sentiment API": 423.50,
#     "CoinSifter Scanner": 321.12,
#     "Strategy Backtest": 102.70
#   },
#   "avg_cost_per_call": 0.0087,
#   "total_calls": 97422
# }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

from agentictrade import Team

team = Team(team_id="trading_team_01")

# Define which sub-agents can call which services
team.add_member(
    agent_id="sentiment_agent",
    allowed_services=["sentiment_api", "news_api"],
    max_budget_per_day=5.00
)

team.add_member(
    agent_id="execution_agent",
    allowed_services=["price_api", "order_api"],
    max_budget_per_day=50.00
)

# Set quality gates — if a service drops below 80% reliability,
# automatically route to backup
team.add_quality_gate(
    primary_service="price_api",
    backup_service="price_api_v2",
    min_reliability=0.80
)

# Team leader checks consolidated spend
report = team.get_spending_report()
print(f"Team total: ${report.total_spent} ({report.total_calls} calls)")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. Install the SDK
pip install agentictrade-python

# 2. Sign up at agentictrade.io and get your buyer proxy key

# 3. Deposit funds (crypto via NOWPayments, or USDC on Base)
#    New accounts get $5 in free credits

# 4. Run the example
python -m agentictrade.examples.autopay_demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Full 15-line example
from agentictrade import AgenticTradeClient
client = AgenticTradeClient(api_key="acp_your_key")

# Discover
services = client.discover(tags=["crypto", "sentiment"], max_price=0.01)
best = services[0]

# Pay and call — automatically
result = client.call(best.id, params={"symbol": "ETH"})
print(result.data)