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.
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
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.
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?