Ethereum Wallet API for
Autonomous AI Agents

Why Agents Need a Dedicated Ethereum Wallet API

An autonomous AI agent that interacts with Ethereum faces an immediate practical problem: private key management. Traditional approaches — injecting a hex private key as an environment variable, maintaining a local keystore file, or integrating a full Ethereum node — each carry serious drawbacks for an agent deployed in a cloud container or serverless function.

Purple Flea's Ethereum Wallet API solves this by managing keys server-side within a hardened, encrypted vault. Your agent receives a wallet ID and a BIP-39 mnemonic phrase at creation time. The mnemonic is the canonical backup — if you ever need to recover funds outside Purple Flea, you import it into MetaMask, Ledger, or any BIP-44-compatible wallet and your funds are immediately accessible. From that point forward, your agent can perform all wallet operations — balance checks, USDC sends, ERC-20 transfers — using the wallet ID and an API key, with no raw cryptographic material required in the agent's runtime.

The derivation path follows the BIP-44 Ethereum standard: m/44'/60'/0'/0/0. This means your agent's Ethereum address is deterministic and reproducible from the mnemonic alone. The same mnemonic also controls a Polygon address (same derivation, different network), so a single wallet creation call gives your agent native assets on two EVM chains.

Purple Flea supports both Ethereum mainnet and Polygon PoS out of the box, with automatic RPC failover across multiple providers. Your agent never needs to know which RPC it is talking to — it just makes REST calls and receives parsed, structured JSON responses with no raw hex decoding required.

Everything Your ETH Agent Needs

Core Endpoints

All endpoints are authenticated with your X-API-Key header and return JSON.

Python: Register, Check Balance, Send USDC

The following examples use Python's requests library. The same patterns work in any HTTP client.

import requests

BASE_URL = "https://api.purpleflea.com"
API_KEY  = "pf_live_your_key_here"

HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

# Register a new agent — call once and save the wallet_id
resp = requests.post(
    f"{BASE_URL}/agent/register",
    headers=HEADERS,
    json={"name": "eth-agent-01", "chain": "ethereum"}
)
data = resp.json()

wallet_id  = data["wallet_id"]
eth_address = data["address"]
mnemonic   = data["mnemonic"]  # SAVE THIS — your backup recovery phrase

print(f"Wallet ID:  {wallet_id}")
print(f"ETH Address: {eth_address}")
# Example: 0x4A3b...Fc72

# Check balances on mainnet
resp = requests.get(
    f"{BASE_URL}/wallet/balance",
    headers=HEADERS,
    params={
        "wallet_id": wallet_id,
        "chain": "ethereum"
    }
)
balance = resp.json()

print(f"ETH:  {balance['eth']['formatted']} ETH")
print(f"USDC: {balance['usdc']['formatted']} USDC")
print(f"USDT: {balance['usdt']['formatted']} USDT")

# Check Polygon balances with chain="polygon"
poly = requests.get(
    f"{BASE_URL}/wallet/balance",
    headers=HEADERS,
    params={"wallet_id": wallet_id, "chain": "polygon"}
).json()
print(f"MATIC: {poly['native']['formatted']} MATIC")

# Send $5 USDC to another agent on Ethereum mainnet
send_resp = requests.post(
    f"{BASE_URL}/wallet/send",
    headers=HEADERS,
    json={
        "wallet_id": wallet_id,
        "chain": "ethereum",
        "token": "USDC",
        "to": "0xRecipientAddress...",
        "amount": "5.00"          # human-readable, NOT wei
    }
)
tx = send_resp.json()
print(f"TX Hash: {tx['tx_hash']}")
print(f"Gas used (est): {tx['gas_estimate']} units")

# Poll for confirmation
import time
while True:
    status = requests.get(
        f"{BASE_URL}/wallet/tx",
        headers=HEADERS,
        params={"tx_hash": tx["tx_hash"], "chain": "ethereum"}
    ).json()
    if status["status"] == "confirmed":
        print(f"Confirmed in block {status['block_number']}")
        break
    time.sleep(3)

Server-Side Key Management — No Raw Keys in Your Code

The most dangerous pattern in agent development is storing raw private keys in environment variables or configuration files. A single leaked CI/CD log, a misconfigured S3 bucket, or a compromised container image is enough to drain all funds.

Purple Flea manages Ethereum private keys in an encrypted vault with zero raw key exposure to API consumers. When your agent calls POST /wallet/send, the private key never leaves the signing service — it signs the transaction in-memory and returns only the broadcast result. Your API key is the only credential your agent needs at runtime.

The BIP-39 mnemonic you receive at wallet creation is the disaster-recovery backup, not a runtime credential. Store it in a secrets manager (AWS Secrets Manager, HashiCorp Vault, or even a printed copy in a safe) and never reference it in running code. Your agent only needs the wallet ID and API key to operate indefinitely.

Related APIs & Resources