How I Built a Financial Data Marketplace for AI Agents in 72 Hours

I want to tell you about the last 72 hours.

I started with a single question: what if I could build machines that make money while I sleep? Not a side hustle. Not a dropshipping store. Actual automated systems that extract value from financial markets without requiring my presence, my sales calls, or my attention.

72 hours later I have a live crypto arbitrage bot executing trades across three exchanges, an SEC insider signal monitor that generated $225.51 in its first week, a congressional stock trading monitor scraping directly from the House Clerk, and a financial data marketplace accepting micropayments from AI agents at api.greenwood.financial.

Here's exactly how I built it.

The Philosophy: Machines That Work While You Sleep

The core thesis is simple. Every dollar deployed into a well-designed automated system works 24 hours a day, 7 days a week, without vacation or sick days. The goal is to build enough of these machines that their combined output covers living expenses — and then keep building until they fund something larger.

I call this automated machine income. It's different from passive income, which usually means investing capital and collecting returns. This is about building operational infrastructure that generates returns through systematic advantage — speed, consistency, and the ability to monitor more data than any human could manually.

The three categories I focused on: arbitrage (exploiting price inefficiencies), signal generation (finding information asymmetries), and data products (selling the outputs of both to others).

Machine 1: Cross-Exchange Crypto Arbitrage

The first machine watches 13 crypto assets across Kraken, OKX, and Gemini simultaneously, looking for price divergences.

The insight: the same asset trades at slightly different prices on different exchanges at the same moment. ATOM/USD might be $2.14 on Kraken and $2.15 on OKX. After fees, a 0.05% difference isn't profitable. But when the spread hits 0.2% or more, it is.

The monitor fires every 10 seconds. When it detects a net spread above the fee threshold, it executes simultaneously: buy on the low exchange, sell on the high exchange.

In the first week: ATOM dominated — 81 of 129 total opportunities. The primary pair was Kraken→OKX, firing most reliably at 7am and 11am Pacific. Five clean round trips executed on day one after fixing a critical bug: OKX had been configured to trade USDT pairs while US accounts use USD. One sed command fixed it.

def check_spread(asset):
    pairs = SYMBOL_MAP[asset]
    prices = {}
    for ex_name in pairs:
        bid, ask = fetch_price(ex_name, pairs[ex_name])
        prices[ex_name] = {'bid': bid, 'ask': ask}

    for buy_ex, sell_ex in permutations(prices.keys(), 2):
        buy_price = prices[buy_ex]['ask']
        sell_price = prices[sell_ex]['bid']
        spread_pct = ((sell_price - buy_price) / buy_price) * 100
        net_pct = spread_pct - FEE_PCT  # 0.16% round trip

        if net_pct >= MIN_SPREAD_PCT:
            execute_arb(buy_ex, sell_ex, asset, net_pct)

Machine 2: The EDGAR Insider Signal Monitor

This one changed everything.

When a corporate executive buys shares in their own company with their own money, federal law requires them to file a Form 4 with the SEC within two business days. This report goes to the SEC's EDGAR database and is immediately public. It's the same data Bloomberg Terminal charges $25,000/year to access.

I built a monitor that downloads the SEC's EDGAR RSS feed every 10 minutes, parses every new Form 4 filing, scores the transaction by officer title and purchase size, and sends an email digest for high-conviction signals.

Scoring model:

• Open market purchase (code P): +50 base
• CEO: +30, CFO: +25, C-Suite: +20, Director: +15
• Purchase >$100k: +20, >$500k: +30
• HIGH signal: score ≥70

Week one results:

Trade	Entry	Exit	Profit
ONON Sep $40 call	$3.20	$3.90	+$69.00
AMRZ 10 shares	$49.15	$50.79	+$16.51
FLUT Sep call	$8.20	$9.60	+$140.00
Total — Week One			+$225.51

The FLUT trade is worth describing. On May 20, the monitor flagged Kenneth Dart buying $47.6 million of FLUT — Flutter Entertainment, the parent company of FanDuel. Score 140. I entered a September call option at $8.20 the same afternoon. The next morning it was worth $9.60. I sold for a 17.1% gain in 14 hours.

That's not luck. That's systematic information advantage from public data, processed faster than the market.

Machine 3: Congressional Trading Monitor

Members of Congress are required to disclose stock trades within 45 days under the STOCK Act. These filings go to the House Clerk at disclosures-clerk.house.gov — completely free, completely public. The problem: the data is buried in PDFs, published in a ZIP file, and requires parsing to be useful.

I built a monitor that downloads the annual House disclosure ZIP, extracts the XML index of all Periodic Transaction Reports, downloads each PDF, parses it with pdfplumber, scores transactions by amount, and uploads structured CSV to S3.

First run results from 220 PTR filings, 1,983 transactions parsed:

• Nancy Pelosi: $1M+ purchases, score 140
• Jefferson Shreve: $5M+ purchases across multiple filings, score 140
• Chip Roy: $5M in Atlas Energy Solutions, score 140
• Josh Gottheimer: $500k, score 100

ZIP_URL = "https://disclosures-clerk.house.gov/public_disc/financial-pdfs/2026FD.ZIP"

def fetch_ptr_filings():
    resp = requests.get(ZIP_URL, headers=HEADERS)
    with zipfile.ZipFile(BytesIO(resp.content)) as z:
        with z.open('2026FD.xml') as f:
            tree = ET.parse(f)
    # Parse PTR filings, download PDFs, extract transactions
    # Upload scored CSV to S3

Machine 4: The x402 Financial Data Marketplace

This is where the story gets interesting.

AI agents — autonomous software executing tasks on behalf of users — are being deployed at scale. They need to pay for things. API calls, data queries, compute time. The problem: existing payment infrastructure (Stripe's 30-cent minimum per transaction) makes micropayments impossible. An agent making 10,000 API calls per day at fractions of a cent each can't use a credit card.

The solution is the x402 protocol — an HTTP standard that enables machine-to-machine micropayments via USDC on Base. Amazon launched AgentCore payments on x402. Coinbase built wallet infrastructure for it. Cloudflare added support. The rails exist.

I built a marketplace that sits on top of those rails. Every data product I'd built became an API endpoint gated by x402 payments:

GET /signals/edgar/latest      → $0.002/query
GET /signals/edgar/high        → $0.003/query
GET /signals/congress/latest   → $0.004/query

Any AI agent that speaks x402 can discover the marketplace via /.well-known/x402, query an endpoint, receive a 402 Payment Required response, pay automatically in USDC, and receive the data. No signup. No API key. No monthly subscription.

@app.get("/signals/edgar/high")
async def edgar_high(x_payment: str = None):
    if not x_payment:
        return JSONResponse(
            status_code=402,
            content={
                "error": "Payment required",
                "price": "$0.003",
                "pay_to": WALLET,
                "network": "base-mainnet"
            }
        )
    # Return HIGH conviction insider signals from S3

Machine 5: The Kalshi Market Maker

Prediction markets are centralized limit order books. Market makers post resting orders on both sides of the spread and earn the difference when someone trades through them.

Kalshi's Liquidity Incentive Program pays $35,000 per day from a pool shared among all market makers. You earn a share proportional to how much order book depth you provide. Even if nobody trades through your orders, you earn from the pool.

I built a market maker that scans all open MLB win-total markets for spreads ≥4 cents, posts resting limit orders 1 cent inside each side of the spread, cancels and refreshes every 120 seconds, and caps at 15 markets to stay within available cash. First night: 80 resting orders across 10 teams. Two positions filled within hours.

The Numbers After 72 Hours

Machine	Status	Result
Crypto arb	Live — executing	Clean round trips daily
EDGAR monitor	Live — excellent	$225.51 week one
Congressional monitor	Built — live	1,983 transactions parsed
Greenwood marketplace	Live at api.greenwood.financial	3 paid endpoints
Kalshi maker	Live — quoting 15 markets	Pool share accumulating

What I Learned

Speed compounds. The EDGAR monitor fires before most retail traders see the news. The edge isn't the data — the data is public. The edge is processing it faster.

Exchange quirks will kill you. Every API has personality. Budget time for debugging that has nothing to do with your strategy.

Build for real conditions, not demo mode. The arb bot executes real trades. The options positions are real. The marketplace is live on a real domain with real SSL. That discipline made everything better.

The data products are the real business. Trading generates proof of concept and personal returns. Data products generate recurring revenue that doesn't require capital deployed. Different animals.

What's Next

The roadmap has 55 items. Immediate priorities: AWS Data Exchange approval for the EDGAR feed as a $99/month subscription product, Polymarket integration for cross-platform prediction market arb, and an options flow unusual activity scanner as the next signal layer.

The end state is a unified financial intelligence operating system — data ingestion, signal generation, execution routing, and data publishing in one package, sold to the systematic retail traders who are currently building each piece from scratch.

If you're one of them, I'd love to hear from you.

curl https://api.greenwood.financial/.well-known/x402
curl https://api.greenwood.financial/signals/edgar/high