1
2 Comments

I built a tool that finds funding arbitrage opportunities in real time (up to 200%+ APR)

For the past months I’ve been trading funding rate arbitrage across multiple DEXs and CEXs.

Some of the spreads I was seeing were 50%–200% APR — but almost impossible to capture manually.

At first I did everything manually:
– checking funding rates
– comparing spreads
– trying to open positions fast enough

But it always ended the same way:

By the time I found a good opportunity… it was already gone.

So I built my own system.

👉 What it does:
– tracks funding rates across exchanges in real time
– detects long/short arbitrage setups instantly
– helps execute before spreads disappear

Over time I added:
– a scoring system to rank the best opportunities
– monitoring of 500+ tokens
– execution-focused signals (not just theoretical setups)

The biggest realization:
👉 finding opportunities is easy
👉 execution speed is the real edge

Now I use it daily — and the difference vs manual trading is huge.


I ended up turning it into a product:
👉 https://arbex.io/signals

(Not trying to sell — just sharing what’s working for me.)


Also testing something interesting:

I launched a referral system where traders can earn recurring commissions (up to 25%) by sharing it.

👉 https://arbex.io/referrals

Curious if distribution through traders works better than paid ads.


Recently I’ve also started building custom setups:
– private arbitrage bots
– execution infrastructure
– white-label solutions

This part is evolving faster than I expected.


Would love feedback from anyone working on:
– arbitrage
– market-neutral strategies
– automated trading
– or building in crypto in general

on March 29, 2026
  1. 2

    interesting approach. the execution speed point is spot on — i built something similar for cold outreach (scraping agency websites and sending personalized emails) and the same principle applies. by the time you manually find a good prospect and craft an email, the window has moved. automation that acts in real-time is the only way to scale. curious how you handle the latency between exchanges for the actual trade execution.

    1. 1

      Appreciate this — and yeah, completely agree, execution speed is the real edge.

      That’s actually where most of the system complexity ended up.

      Right now the approach is:

      – near-simultaneous execution across both exchanges
      – trades only trigger above a safety threshold (~1%+ after fees/slippage)
      – if execution conditions aren’t clean, the system skips the trade entirely

      What I found is that detecting opportunities is relatively easy…
      but capturing them consistently is a completely different problem.

      Latency between exchanges is definitely the biggest constraint — especially when spreads compress in seconds — so I’ve been prioritizing execution quality over frequency.

      Less trades, but cleaner ones.

      Also experimenting with:
      – tighter execution coordination
      – reducing API roundtrip delays
      – and more controlled environments for order placement

      Still a lot to improve here, but that’s where most of the edge seems to be.

      Curious — in your case, did you also notice that once execution was solved, everything else became secondary?

Trending on Indie Hackers
The most underrated distribution channel in SaaS is hiding in your browser toolbar User Avatar 185 comments I launched on Product Hunt today with 0 followers, 0 network, and 0 users. Here's what I learned in 12 hours. User Avatar 159 comments How are you handling memory and context across AI tools? User Avatar 100 comments I gave 7 AI agents $100 each to build a startup. Here's what happened on Day 1. User Avatar 98 comments Do you actually own what you build? User Avatar 59 comments Show IH: RetryFix - Automatically recover failed Stripe payments and earn 10% on everything we win back User Avatar 34 comments