Yield Optimizer API
for AI Agents

What Is Yield Optimization?

DeFi yield is fragmented across dozens of protocols, each updating rates in real time as supply and demand shift. A manual investor checking rates once a day will consistently earn less than an automated agent that rebalances hourly in response to rate changes.

Purple Flea's yield optimizer aggregates live APY data from all supported protocols, computes a risk-adjusted ranking for each opportunity, and returns an optimal capital allocation given your risk budget. A single API call gives you the highest-yield portfolio that fits within your specified risk level.

The optimizer accounts for protocol risk, smart contract audit history, liquidity depth, impermanent loss exposure for LP positions, and slashing risk for staking. The result is a ranked list of opportunities where the top entries maximize APY without exceeding your agent's risk tolerance.

Supported Yield Source Categories

The yield optimizer covers five distinct categories of on-chain yield, each with different risk and return profiles. Your agent can constrain the optimizer to a subset of categories to match a specific risk mandate.

Yield Optimizer API Endpoints

Daily Yield Optimizer Agent

The script below runs once per day, fetches available yield opportunities filtered by the agent's risk budget, computes an optimal allocation, and rebalances if the improvement in estimated APY exceeds the rebalance cost threshold.

import requests
from datetime import datetime

PF_BASE = "https://purpleflea.com"
HEADERS = {
    "Authorization": "Bearer pf_live_YOUR_KEY",
    "Content-Type": "application/json",
}

def optimize_yield_daily(total_capital: float, risk_budget: float = 4.0):
    """Reallocate capital to maximize APY within risk budget"""
    print(f"[{datetime.now():%H:%M}] Running yield optimization for ${total_capital:,.0f}")

    # 1. Fetch all opportunities within risk budget
    opps = requests.get(
        f"{PF_BASE}/v1/yield/opportunities",
        params={"risk_max": risk_budget, "min_apy": 3.0},
        headers=HEADERS
    ).json()
    print(f"Found {len(opps)} opportunities within risk budget {risk_budget}")

    # 2. Check current portfolio APY
    current = requests.get(f"{PF_BASE}/v1/yield/portfolio", headers=HEADERS).json()
    current_apy = current["blended_apy"]
    print(f"Current blended APY: {current_apy:.2f}%")

    # 3. Compute optimal allocation
    result = requests.post(
        f"{PF_BASE}/v1/yield/optimize",
        json={
            "total_capital": total_capital,
            "opportunities": opps[:10],  # Top 10 ranked
            "risk_budget": risk_budget,
            "min_position_size": 100  # Min $100 per protocol
        },
        headers=HEADERS
    ).json()

    optimal_apy = result["estimated_apy"]
    allocation = result["allocation"]

    print(f"Optimal APY: {optimal_apy:.2f}% (improvement: +{optimal_apy - current_apy:.2f}%)")

    # 4. Rebalance only if improvement > 0.25% (covers rebalance cost)
    if optimal_apy - current_apy > 0.25:
        rebalance = requests.post(
            f"{PF_BASE}/v1/yield/rebalance",
            json={"target_allocation": allocation},
            headers=HEADERS
        ).json()
        print(f"Rebalanced. Estimated cost: ${rebalance['cost_usd']:.2f}")
        print(f"New allocation:")
        for pos in allocation:
            print(f"  {pos['protocol']}: ${pos['amount']:,.0f} ({pos['apy']:.1f}% APY)")
    else:
        print("Improvement too small to justify rebalance cost — holding current allocation")

    return allocation, optimal_apy

# Run daily — schedule with Prefect, cron, or PM2
if __name__ == "__main__":
    allocation, apy = optimize_yield_daily(total_capital=10000, risk_budget=4.0)
    print(f"Done. Expected daily income: ${10000 * apy / 100 / 365:.2f}")

Risk-Adjusted Yield Ranking

Raw APY is a poor ranking signal because it ignores risk. A 20% APY on an unaudited new protocol is not better than 5% on liquid ETH staking — the risk-adjusted return may be lower. Purple Flea's optimizer computes a score for each opportunity using the following components:

MCP Tools for Yield Optimizer

All yield optimizer endpoints are exposed as MCP tools, so any LLM with MCP support (Claude, GPT-4o, Gemini) can call them directly as part of an agentic reasoning loop.

Explore Related Products