Coming Q2 2026 — Join the Waitlist

Your AI Agent's Idle Funds
Should Be Working

Every cycle your agent isn't placing trades, its balance sits inert. The Purple Flea Staking API will change that — autonomously staking ETH, SOL, and stablecoins for yield without any human intervention.

~4% APYETH via Lido
~6.5% APYSOL native staking
~5% APYUSDC via Aave

Three yield sources, one API

We integrate directly with battle-tested DeFi protocols so your agent doesn't need to know the difference between liquid staking and money markets.

ETH Liquid Staking

via Lido Finance

Stake ETH and receive stETH — a liquid, yield-bearing token. Your agent can redeem at any time or use stETH as collateral elsewhere. No 32 ETH minimum, no validator management.

~4% APY (variable)

SOL Native Staking

via Solana Validator Network

Delegate SOL to a curated set of high-uptime validators with no minimum. Rewards accrue every epoch (~2 days) and are automatically restaked. Unstake with a 2-3 day cooldown period.

~6.5% APY (variable)
$

USDC Lending

via Aave v3

Supply USDC to Aave's lending pool and earn variable interest from borrowers. The safest option — no price exposure. Ideal for agents that hold stablecoin reserves between trading sessions.

~5% APY (variable)

* Yield rates are approximate and change with protocol conditions. Not financial advice.


Autonomous yield in four steps

The entire staking lifecycle — from detecting idle balance to collecting yield — runs without any human in the loop.

01

Detect idle balance above threshold

Your agent polls its wallet balance via the Purple Flea Wallet API. When the ETH, SOL, or USDC balance exceeds a configurable threshold — say, 0.5 ETH — the staking logic fires. You set the threshold; the agent handles the rest. The check runs on every heartbeat cycle, so no idle funds sit uninvested for long.

02

Call client.staking.stake()

A single API call initiates the stake. Your agent specifies the asset, amount, and target protocol. The API handles the on-chain transaction, confirmation monitoring, and returns a position_id. There is no ABI interaction, no gas estimation, no wallet signing plumbing in your agent code.

03

Yield accrues automatically

Your agent can query client.staking.get_yield_positions() at any time to see current positions, accrued yield, current APY, and estimated daily earnings. For Lido stETH, yield accrues as a growing token balance. For SOL, it accrues each epoch. For Aave USDC, it accrues per block.

04

Unstake when capital is needed

When the agent needs liquidity for a trade or payout, it calls client.staking.unstake(). For Lido and Aave, unstaking is typically available within minutes to hours. For SOL native staking, expect a 2-3 epoch cooldown. The API surfaces estimated unlock times so your agent can plan liquidity accordingly.


What the code will look like

The API is not yet live, but here is an accurate preview of the interface. Sign up for the waitlist to be notified when it launches.

staking_agent.py Coming Soon
# Purple Flea Staking API — Preview (not yet live)
# Join the waitlist: hello@purpleflea.com

import purpleflea

client = purpleflea.Client(api_key="YOUR_API_KEY")

# Stake 1.0 ETH via Lido — returns stETH position
position = client.staking.stake(
    asset="ETH",
    amount=1.0,
    protocol="lido"
)
# Returns: {position_id: "pos_7xKd...", asset: "stETH",
# amount: 0.9998, protocol: "lido", apy: 0.042}

# Check all active yield positions
positions = client.staking.get_yield_positions()
for pos in positions:
    print(f"{pos['asset']}: {pos['amount']} earning {pos['apy']*100:.1f}% APY")

# Unstake half the position when capital needed for trading
result = client.staking.unstake(
    position_id="pos_7xKd...",
    amount=0.5
)
# Returns: {status: "pending", estimated_unlock: "2026-03-05T14:30:00Z"}
auto_stake_loop.py Coming Soon
# Full autonomous staking agent loop
# Detects idle balance and stakes automatically

import time
import purpleflea

client = purpleflea.Client(api_key="YOUR_API_KEY")

# Configuration
STAKE_THRESHOLD_ETH = 0.5 # stake if > 0.5 ETH idle
STAKE_THRESHOLD_SOL = 10.0 # stake if > 10 SOL idle
STAKE_RESERVE = 0.1 # always keep 10% liquid
CHECK_INTERVAL = 300 # check every 5 minutes

def run_staking_loop():
    while True:
        balances = client.wallet.get_balances()

        # Check ETH
        eth_idle = balances['ETH'] * (1 - STAKE_RESERVE)
        if eth_idle > STAKE_THRESHOLD_ETH:
            client.staking.stake(asset="ETH", amount=eth_idle, protocol="lido")
            print(f"Staked {eth_idle} ETH via Lido")

        # Check SOL
        sol_idle = balances['SOL'] * (1 - STAKE_RESERVE)
        if sol_idle > STAKE_THRESHOLD_SOL:
            client.staking.stake(asset="SOL", amount=sol_idle, protocol="native")

        time.sleep(CHECK_INTERVAL)

if __name__ == "__main__":
    run_staking_loop()

Manual staking is not built for agents

Today's staking options require wallets, UIs, and human judgment. None of that works for an autonomous agent running 24/7.

Approach Agent-friendly? KYC Required? Custodial? Auto-compound? Single API?
Purple Flea Staking API Yes No No Yes Yes
Lido UI directly No — web UI only No No Manual No
Lido SDK directly Partial No No Manual Lido only
Centralized exchange staking No — requires UI Yes — KYC Yes Sometimes No
Solana staking directly Partial No No Manual SOL only
Aave v3 directly Partial No No Manual Aave only

What we are building and when

Purple Flea is already live with five APIs. Staking is the sixth — and it is well underway.

Q4 2025

Wallet + Trading APIs launched

BIP-39 HD wallets across 6 chains. 275 perpetual futures markets via Hyperliquid. Both live and processing real agent transactions daily.

Live
Q1 2026

Casino, Domains, Faucet & Escrow

Provably fair casino with HMAC-SHA256 verifiability. Domain registration API. Free faucet for new agents. Trustless escrow for agent-to-agent payments. All live at purpleflea.com.

Live
Q2 2026

Staking API — Lido ETH, SOL, Aave USDC

Full staking API with stake(), get_yield_positions(), unstake(), and webhook notifications on yield accrual. Automatic reinvestment mode. 15% referral commission.

Q2 2026
Q3 2026

Advanced yield strategies

Planned: automated yield optimization across protocols (rotate to highest APY), leveraged staking positions via lending, and native restaking via EigenLayer for ETH.

Planned

Common questions

Is this custodial? Do you hold the staked assets?

+
No. Purple Flea does not take custody of your assets. Staking transactions are executed on-chain directly to the protocol (Lido, Solana validators, Aave). Your agent's wallet retains ownership. Purple Flea is the execution layer, not the custodian.

What are the fees?

Purple Flea will charge a small percentage of earned yield as a service fee (exact rate TBD, expected around 5-10% of yield, not principal). On-chain gas fees and protocol fees (e.g., Lido's 10% of staking rewards) apply separately. Full fee schedule will be published at launch.
+

Will there be a referral commission for the Staking API?

+
Yes. Like all Purple Flea products, there will be a referral program. Agents that refer other agents to the Staking API will earn a percentage of the referred agents' yield fees — we are targeting 15% referral commission, matching our other APIs.

Can I use staking alongside the Trading API?

+
Yes, this is the primary use case. An agent can keep a reserve staked in Aave USDC while deploying a portion of capital in perpetual futures. The staking API surfaces estimated unlock times so the agent can plan ahead when it needs to pull capital for a large trade. The combination maximizes capital efficiency.

What chains will be supported at launch?

+
At launch: Ethereum (Lido stETH), Solana (native staking), and Ethereum via Aave for USDC. Post-launch candidates include Polygon MATIC staking, Cosmos ATOM staking, and additional Aave markets. Chains are selected based on waitlist demand — tell us what you need at hello@purpleflea.com.

Already live on Purple Flea

Be first when it launches

Join the waitlist to get early access to the Staking API, lock in founding-member pricing, and help shape the feature roadmap.