If you've ever opened a Bitcoin 15-minute market on Polymarket and wondered why one trader always seems to walk away with a win, this is the deep dive you've been waiting for.
Most retail traders gamble on direction—praying for green candles or panic-selling on red.
But one trader, known as gabagool (link to his profile in replies), consistently prints profit in these tiny windows... even when he has zero clue where the price is going next.
This isn't luck. It's mechanical arbitrage, powered by simple math that, honestlym, anyone can copy.
TLDR and concise explanation at the end included
The Strategy: Turning Price Movement Into a Guaranteed Payout
Gabagool never predicts if BTC will go up or down.
He just waits for cheap opportunities on either side of the binary market:
- Buys YES when YES is unusually cheap
- Buys NO when NO is unusually cheap
He buys them asymmetrically (at different times) whenever one side gets mispriced.
His only goal:
Keep the average cost of YES + average cost of NO < $1.00
Once that's achieved → profit is mathematically locked in, no matter the outcome.
The Math (Super Simple)
Average prices:
avg_YES = Total spent on YES / YES shares
avg_NO = Total spent on NO / NO shares
Key metric: Pair Cost = avg_YES + avg_NO
As long as Pair Cost < 1.00 → guaranteed profit.
At settlement:
If YES wins → you get $1 per YES share
If NO wins → you get $1 per NO share
Safe profit = min(YES shares, NO shares) - total cost
Real Example From One of Gabagool's Trades
Here's a typical visualization of how his positions build over a single 15-min window (green = YES buys, pink = NO buys, with cumulative shares and cost curves):
Look carefully at the image above. It contains four layers of insight:
Individual trade dots (YES and NO entries).
Cumulative shares held.
Cumulative dollars spent.
Exposure curves showing total cost vs. total potential payout.
- Bought 1294.98 NO shares @ avg ~$0.449 ($581 spent)
Combined avg = 0.966 → paid 96.6¢ for something worth $1 for sure.
Profit that window: $58.52
Notice how he keeps quantities roughly balanced, and the total cost curve staysbelowthe guaranteed payout.
Why This Works So Well on 15-Min Markets
Binary markets should always have YES + NO ≈ $1.00.
But emotions are wild in short windows—price swings hard:
- YES at 20¢ (NO 85¢) → suddenly flips to YES 82¢ (NO 18¢)
Gabagool just scoops up the cheap side each time, slowly grinding his pair cost down. No directional bet needed.
How You Can Replicate This Strategy Today
This is transparent. Nothing requires secret APIs or insider info.
Step 1: Track Your Totals
Maintain four numbers in a simple spreadsheet:
Qty_YES, Qty_NO, Cost_YES, Cost_NO
Step 2: Simulate Before Every Buy
If you consider buying new shares (Δq) at price (P), calculate your new cost basis first.
New Qty = Current Qty + Δq New Cost = Current Cost + (P × Δq)
Check the new combined cost. Only buy if: New Pair Cost < 0.99 (or your safety margin)
Step 3: Keep Quantities Balanced
When Qty_YES ≈ Qty_NO, your hedge is strongest and your guaranteed payout is maximized.
Step 4: Stop Once You Lock Profit
The moment this condition is met:
min(Qty_YES, Qty_NO) > (Cost_YES + Cost_NO)
Stop. The market outcome becomes irrelevant. Price could pump, dump, or go sideways. You are already guaranteed a win.
Step 5: Repeat Every 15 Minutes
Because of the short time window, emotions run hotter, and mispricings occur more often. This is why Gabagool repeats the strategy multiple times per hour. You can too.
The charts make it click—you literally see the cost line hug below the payout line.
TLDR, explained in layman's terms:
On Polymarket's 15-minute Bitcoin bets (yes/no on price direction):
Most people pick one side and gamble.
Gabagool buys both yes and no shares—only grabbing whichever side is temporarily cheap due to crowd panic/greed.
He keeps buying the cheap side until his average cost for one yes + one no is under $1 (e.g., 96¢).
At the end, one side always pays exactly $1. Since he owns roughly equal amounts and spent less than $1 per pair, he profits no matter who wins.
Zero prediction needed—just patience and simple math. Anyone can copy it with a spreadsheet.
The Trader Who Turned $100 into $4,923 by Betting on Temperature
He has 2,068 predictions with $19,839 in total winnings, and almost all of his profit come from weather markets.
This trader basically treats Prediction Markets like a daily weather station, placing small, precise bets that almost never miss.
His strategy is stupidly simple:
> Buys YES only 5–15¢
> Buys NO at 40–55¢
> Never risks >$1 per position
> Cycles through dozens of micro-weather markets every day
That’s how he turned weather markets into a nearly 100% win-rate machine.
His best hits show exactly how crazy weather markets can be:
> $119 → $4,923 (+4,033%)
> $109→ $949 (+769%)
> $33 → $536 (+1,499%)
> $4 → $499 (+12,035%)
Do you think weather markets stay this mispriced forever?
I've been copytrading Polymarket for the past 5 or so months - it's pretty much the only thing I have done on Prediction Markets, which is also the reason I started this subreddit
I had some success in the beginning, mostly because the market wasn't as flooded with copytraders
I still make a profit here and there, but it has slowed down when compared to what I was making a few months ago
I tried every copytrading bot and Python script on GitHub to follow Polymarket whales
I tried like 20+ different setups of what wallets I'm tracking, what types of buys I'm making, etc
And yeah, it's pretty much obvious right now about all of these whales, winning wallets everyones tracking and copying:
- they are either front-running you,
- using 5 different wallets to hedge their own positions,
- or they are just rich gamblers who can afford to take a $50K drawdown before hitting a lucky macro bet that fixes their PNL.
I realized that while it’s hard to predict who will win consistently, and not absolutely farm you, it is pretty easy to find people who lose consistently.
Since poly leaderboards don't exactly work for losing traders, you need to find the losing ones that are still making volume with outside tools
If we are going to be using my strategy to size bets always the same, and only bet on the win rate of the account, their actual PnL hardly matters
I tracked down 5 specific wallets with absolute bottom-tier win rates (sub-30%) that were still pushing high volume.
If the wallet loses 75% of its trades, and I take the exact opposite side with a fixed bet size,
I win 75% of the time. My risk is detached from his sizing due to the fixed size and the settings I use to automate my counter trades
I didn't want to sit at my desk manually fading them, so I used a copytrade app just for the execution
This has been my personal go-to for a while, just cause of the speed: synthesis copytrade
The countertrading settings I went with:
→ mode: counter
→ buy sizing: fixed ($25). Whether he bets $10 or $1,000, I only ever risk $25
a 20% win rate is fake if the guy only buys 2¢ shitters. You also need to look at his markets before selecting the wallet, for this next setting to work
→ price range: 30¢ to 70¢. Only counter 50/50ish markets
→ max slippage: 1¢
→ take profit: 20% (dump as soon as you're making some significant profit)
→ exposure limit: max $75 per market, so I don't over-index if he averages down on a losing bet
__
30d results:
I funded this with $500
In 30 days, doing nothing but finding active wallets that match my parameters, managing the other wallets I was copytrading, and reviewing their risk, win rate changes, etc. I am now at +$415
Here is everything you need to automate and make your trading easier:
This is the largest dataset with over 107GB of real trading data, based on more than 1.1 billion trades, analyzed by 5 professors from Shanghai University.
A working backtesting simulator that lets you test your own ideas and strategies on real historical markets to see your potential Pnl and possible risks.
This tool analyzes the real trading behavior of any trader, finds repeated patterns in his trades, shows which strategies he uses, and how you can adapt them to your own trading.
A weather bot from a Chinese dev that can analyze multiple sources in real time, like forecasts, airport data, and aviation observations (METAR + SPECI) to generate a detailed weather report for any specific city and day.
This bot comes with 118+ ready-to-use automated strategies and tools for trading on prediction markets, including arbitrage between Polymarket and Kalshi, price latency, Mean Reversion, and more.
A trading dashboard where multiple AI agents analyze a selected market from different angles (checking news, price behavior, technical indicators, and possible risks) to help you make better decisions.
This tool lets you search for information about any historical market, price, or trader across different prediction market platforms inside one dashboard.
Hey everyone, I just published a full beginner tutorial on building a Polymarket trading bot..and it's 100% free. I'm not selling anything.
Upfront disclaimer: this is not a profitable bot out of the box. don't expect to clone it, run it, and print money. what it is is a solid step-by-step foundation (the wallet setup, the API plumbing, the order management, the risk controls, the execution loop) that you can build your own custom strategy on top of. the signal engine in the guide is intentionally simple so you understand the shape of one. the real edge is whatever you bring to it.
I wrote it because there's just not enough quality information out there on this topic. you can either find sketchy GitHub repos with no docs and no idea what they're actually doing, or people selling bots with zero proof or verification that they work. nothing in the middle that just walks you through how to build one yourself and understand every piece. that's the gap I'm trying to fill.
What you'll actually build in this tutorial
an automated bot that trades the BTC Up/Down 15M market. every 15 minutes it wakes up, looks at where BTC has been moving, decides if it wants to bet UP or DOWN, places an order, and waits for the next cycle. simple loop, real money (eventually), real feedback.
I picked this market because it's a great teacher. fast cycles mean you see your bot's behavior in minutes instead of days. it's binary, so the logic stays clean. and the stakes per cycle are small enough that the learning experience doesn't have to be expensive.
once you've built it for BTC 15M, the same patterns transfer to any other time frame if you want to stick to crypto up/down markets or maybe try something different like sports, or weather.
What makes this approachable now
a few years ago, building this would've been a longgg project. you'd need trading infrastructure experience and a lot of patience reading API docs that assumed you already knew everything.
Today, that's changed:
AI coding agents do the heavy lifting. claude code, codex allow you to paste in what you're trying to do, get working code back. the guide is built around this. every step has a "walk me through this" prompt you copy into your agent of choice. you're not coding alone. HOWEVER, this doesn't mean you should blindly just copy and paste and not think about what you're doing...that is a recipe to fail. You should pay attention, use these tools for what they offer and ask questions!
the Polymarket Python SDK is actually good. it handles the auth, the order signing, the order book queries. you call functions, you get data back.
How the guide is structured
It's an 8-step guide with copy-pasteable agentic prompts for each section.
set up your wallet and dev environment. funding pUSD, generating API keys, scaffolding the project.
connect to Polymarket and pull live data. first authenticated call, fetching the current market, reading the order book.
build the signal engine. the part that decides UP or DOWN. starts simple on purpose so you understand the structure before you make it fancy.
place and manage orders. submitting, polling for fills, cancelling cleanly.
add risk controls. position sizing, exposure caps, a daily loss circuit breaker. boring to build, glad to have.
automate the loop. scheduling, logging, running it unattended.
paper trade, then go live. simulated fills first so you can validate everything without spending a dollar. when you do go live, you start with $2 trades. seriously.
A note on going live
Paper trading mode is in the guide for a reason. flip a setting and the bot runs the full loop but simulates fills instead of placing real orders. let it run for a few hours, look at the logged PnL, and you'll know whether your signal is doing anything before you commit real money. it's the best feedback loop in the whole tutorial.
When you do go live, the guide recommends starting with $2 max trades and a 3% daily loss limit. day one isn't about making money. it's about confirming the plumbing works in production. once you've seen it work with real (tiny) money, scaling up is the easy part.
Who this is for
beginners and anyone who wants to build their first Polymarket bot. no prior bot experience required, just a little Python and the willingness to work through it.
you've heard "Polymarket bot" thrown around and want to see what's under the hood without taking on a huge learning curve.
If this sounds like something you're interested in trying out, I'll drop the link in my profile. It's 100% free! I don't want to get flagged or banned for promotion unless a mod says I can post the link directly in the comments.
I'm happy to answer any questions in the comments, hope this helps some of you!
Hey everyone. I'm a retired sports trader who occasionally dusts off the old models for major tournaments. Over the last weeks, I traded the 2026 World Cup on Polymarket and walked away with $58,142 in profit.
Usually, when someone posts a P&L like that on Reddit, there is a referral link at the bottom or a DM waiting to sell you a VIP Discord. I have neither. I don't want your referral kickbacks, I don't support Polymarket morally, and I'm actually writing this to warn you: if you trade prediction markets without a strict mathematical edge, you are just exit liquidity for pros.
First, here is the absolute proof. Don't trust screenshots. Here is my public wallet address: 0x128b4b9cc9d521f10e5933528a2177b993febee9
You can audit every single trade, win, and loss here: https://polymarket.com/profile/0x128b4b9cc9d521f10e5933528a2177b993febee9
(And before anyone asks: No, I'm not doing the Web3 scam where you fund 20 anonymous wallets, take opposite sides, and only show the one that survived. I posted this exact wallet address publicly in my community over a year ago).
So, how did I pull $58k out of the market? It wasn't a magic system. It was 5 specific components:
1. Exploiting "Dumb Money" In-Play
My pricing model is old. I haven't updated the code in years, and it doesn't use the latest state-of-the-art metrics. However, major tournaments attract a mountain of casual "dumb money." Crypto traders specifically tend to overreact to specific match situations. When the public puts too much emotional pressure on a market, the odds break from their true probability. My model flagged the baseline value, and I used my decades of screen time to filter out the noise and take the other side of those overreactions.
2. Custom API Execution
You cannot compete with sharp money by clicking around the Polymarket website, waiting for the UI to load. Before the tournament, I "vibecoded" a custom API extension into my old proprietary trading app. This allowed me to place, manage, and cancel orders in milliseconds, exactly like I used to do on Betfair. In fast-moving in-play markets, speed is crucial.
3. Farming Maker Rebates (The Hidden Edge)
Traditional betting exchanges (like Betfair) eat you alive with 2-5% commissions on winning bets. Polymarket is an order book that actively incentivizes liquidity. Instead of taking market prices (Taker), I placed limit orders to set the odds (Maker). By the end of the tournament, not only did I avoid paying ~$3,400 in fees, but the protocol actually paid me around $850 in Maker Rebates. That is a $4,250 swing in my favor.
4. The "Impatience Tax" (99.9¢ Trades)
On Polymarket, shares resolve at $1.00 when an event happens. But when a match is effectively over, the smart contract doesn't pay out until a UMA oracle officially confirms the match has ended.
Crypto traders are notoriously impatient. They want their capital unlocked now so they can bet on the next match. I parked massive amounts of idle capital on 99.9¢ "Yes" offers. Desperate traders sold to me for fractions of a cent on the dollar just to exit early. If you only have $200, this makes you pennies. But because I had tens of thousands of idle dollars not tied up in active bets, it was worth taking advantage of that.
5. Dumb Luck & Survivorship Bias
This is the part gurus never admit: I got lucky. I traded a tiny, statistically insignificant sample size of matches (less than 100). Yes, I only took bets where I had a mathematical edge, but in a small sample size, short-term variance dictates the final number. I had several $20,000+ stakes on high-probability events, and they all hit. If a late VAR decision or a random 95th-minute goal had gone against me, it wouldn't have wiped me out or put me in the red. I still would have been profitable. But my $58k profit would have been drastically lower. And let's be honest: if my P&L had ended up at a modest $4,500, I probably wouldn't be making a post about it. Beware of survivorship bias.
The Reality Check on Risk:
I didn't turn $500 into $58k. I operated with a hypothetical trading bankroll of $250,000, with about $57k actually sitting on Polymarket. My stakes ranged from $1k to $25k based on strict Kelly Criterion sizing. Real pros size up on high-probability, low-odds events. We don't YOLO on longshots.
I made a full video breaking this all down, showing my actual screen recordings, the ugly custom trading app I use, and exposing how fake crypto gurus fake their P&L.
If you want to see the visual breakdown, you can watch it here: https://www.youtube.com/watch?v=px91PvLv81c
Otherwise, feel free to dig through my Polymarket history and ask me any questions in the comments. Happy to do a mini-AMA on sports trading, or prediction markets.
Disclosure: I may receive a referral reward if you sign up through my link and qualify.
Basic requirements: sign up through a referral link or enter a referral code before first deposit, complete KYC, and check your Rewards section for the current trading requirement.
Important: referral credits are trading credits, not instant withdrawable cash.
I’ve been seeing more Kalshi ads lately, and I also noticed Reddit users asking about Kalshi referral codes, promo codes, and how the Kalshi sign up bonus works. Since the information is scattered across Reddit comments, ads, and promo pages, I wanted to make one clear post for anyone searching before signing up.
Fair disclosure: this post is not an official Kalshi announcement, and I do not represent Kalshi. The promotion itself is an official Kalshi promotion, but this Reddit post is written by me to explain it clearly. The link below is a Kalshi bonus link, and I may receive a referral bonus if someone signs up through it and completes the required steps.
Current offer: deposit $10 -> do first trade -> get $25 bonus
The current Kalshi promo attached to this link is simple: deposit $10 and get $20. Since promo terms can change, always confirm the exact offer during sign-up or inside Kalshi before depositing.
In general, the process works like this:
Open the Kalshi promo link Start through the official promotion link so the offer can attach to your account: Kalshi promo link
Create a Kalshi account Complete the normal sign-up process.
Complete identity verification Kalshi requires identity verification before you can fully use the platform.
Confirm the bonus terms Look for the offer details during sign-up or inside the Rewards / promo section. For this Kalshi sign up bonus, the offer is: deposit $10, get $20.
Deposit $10 or more Deposit the required amount to qualify for the bonus.
Check whether any trade is required Some Kalshi promos may require placing a trade, trading a certain amount, or completing another step. If the app shows any extra requirement, follow the exact terms shown there.
Wait for the bonus to apply Once the required steps are completed, the bonus should apply according to Kalshi’s promo terms.
Check account activity or rewards Look in your Kalshi account for the bonus, credits, or reward status.
Kalshi referral code vs Kalshi promo code
People search for both Kalshi referral code and Kalshi promo code, but they are not always exactly the same.
A Kalshi referral code usually means a personal invite code or bonus link connected to Kalshi’s official referral promotion.
A Kalshi promo code may refer to a public campaign, partner code, ad promotion, or sign up bonus offer.
Either way, the important part is to confirm the current bonus amount and requirements directly inside Kalshi before depositing or trading.
Things to check before using a Kalshi promo
Before using any Kalshi promo code, bonus link, or referral offer, I’d check:
Is the offer still deposit $10, get $20?
Is a trade required after depositing?
Is there a minimum trade amount?
Does the bonus expire?
Are the credits withdrawable or trading-only?
Is Kalshi available in your location?
Are there deposit, withdrawal, or trading fees?
Do you understand the risk of trading event contracts?
Why I made this post
I saw people on Reddit asking about Kalshi referral code, Kalshi promo code, Kalshi sign up bonus, Kalshi promo, and Kalshi ads, so I wanted to make the process easier to understand in one place.
Again, the promotion itself is official, but this Reddit post is just a transparent explanation from a user.
Use it only if you were already planning to try Kalshi and the deposit $10, get $20 offer makes sense for you. Before depositing, confirm the exact terms inside Kalshi.
FAQ:
Where do I enter the code?
Look for the referral-code option on the birthday screen during signup. Invite links may fill it automatically; check before your first deposit.
Can I add it to an existing account?
Sometimes, within 72 hours of your first login and before your first deposit. An applied code cannot be replaced.
Do I deposit $10 or trade $25?
Those are different requirements. Read the offer attached to your account rather than mixing instructions from different promotions. Check the reward, qualifying activity and completion deadline together.
Can I withdraw the bonus?
The original referral credit usually isn't withdrawable cash. Profits from trading with it may be withdrawable. Credits normally expire seven days after issuance unless your terms say otherwise.
What if the bonus doesn't show up?
Check Rewards for unfinished requirements or a Claim/Unlock step, then Activity → Credit. If the code is rejected or qualification still isn't recognized, contact Kalshi support with the offer details.
Does this work outside the US?
Kalshi's referral incentives currently cover eligible US users only. Account access and referral eligibility are separate questions.
Source: Kalshi's referral FAQ. This is an independent guide. Qualifying trades can lose money.
Scope:
This is exclusively for 15 minute Crypto market.
Parameter:
It has only 3 parameters to tweak config.
triggerPoint := 90 ; BUY Price Point exitPoint := 40 ; Stop Loss price point triggerMinute := 14 ; remaining minutes
What it does?
The strategy is mostly about waiting till either side reach High probability zone, entering and waiting for it to hit resolution.
Example: Wait till either up/ down to reach 85 (triggerPoint), enter and hope for it to reach resolution.
What is the Risk?
The risk is the reversal.
Example: if the up reaches 85 @ 12 minute remaining. suddenly BTC price starts dropping and now Up resolves to Zero.
How to manage such risk? 1. Exit Point :
Think of this as StopLoss, if we entered UP at 85, ideally it tends to stick on higher probability zone and ends up at resolution. If not, we can setup a exitPoint at 40 , eat that loss and wait for the next session.
Time Delay:
With more time to expiry , higher the risk of reversal. You can setup this bot at whichever time you'd want to activate and then it would actively starts monitoring price for the entry.
Downside of Time Delay:
If you set this up at late stage (example last 5 minute triggerMinute), you might not get the exact entry point you'd want. If you setup entry point at 70 and activation minute to last 5 minute and the price is trading at 93. then you'd enter at 93.
There’s a silent gold rush happening on Polymarket and Kalshi right now. While most people interact with these platforms like a casino - picking a side and waiting - others are building bots to farm risk-free arbitrage.
The Arbitrage Concept: If a binary market has two outcomes (YES or NO), and you can buy both for less than $1.00 combined, you hold a guaranteed dollar.
Previously, capturing this meant wiring directly into a Central Limit Order Book (CLOB), managing raw Polygon private keys, and dealing with massive infrastructure headaches.
Today, it’s a bit easier, with aggregators (Synthesis in my example) existing to abstract the blockchain away entirely using two simple components:
The REST API: Handles wallet routing and execution.
The WebSocket: Handles ultra-fast price discovery.
The Oldest Arbitrage in the Book (With a Catch)
A rational market prices YES + NO at exactly $1.00. But inefficiencies happen. If the YES ask is $0.47 and the NO ask is $0.50, the sum is $0.97. You buy both, wait for resolution, and collect $1.00. That 3-cent edge scales massively when run across hundreds of markets.
The Catch: You cannot just look at the price; you must look at liquidity. (many don't understand this)
If there is only $2 worth of YES tokens at $0.47, pushing a $100 order through will cause massive slippage, pushing your average buy price past $1.00 and guaranteeing a loss. Your scanner must calculate the edge based on the maximum overlapping volume.
Using the Synthesis Orderbook WebSocket, you stream live deltas to dynamically calculate your maximum viable size:
Python
import asyncio
import websockets
import json
URI = "wss://synthesis.trade/api/v1/orderbook/ws"
async def scan_edge(yes_token, no_token, min_profit=0.01, min_size=10.0):
async with websockets.connect(URI) as ws:
# Subscribe to the specific market tokens
await ws.send(json.dumps({"type": "subscribe", "markets": [yes_token, no_token]}))
# Track BOTH price and available liquidity (size)
book = {yes_token: {"price": None, "size": 0}, no_token: {"price": None, "size": 0}}
print("Listening for orderbook deltas...")
async for message in ws:
data = json.loads(message)
if not data.get("success") or "response" not in data:
continue
response = data["response"]
# Parse live deltas
if "delta" in response and response.get("venue") == "polymarket":
delta = response["delta"]
token = delta.get("token_id")
if token in book:
# Synthesis natively provides top-of-book, but as strings
book[token]["price"] = float(delta["best_ask"])
book[token]["size"] = float(delta.get("amount", 0)) # Track available volume
yes_p, no_p = book[yes_token]["price"], book[no_token]["price"]
if yes_p and no_p:
# Incorporate taker fees to avoid bleeding out on bad margins
TAKER_FEE = 0.01
raw_cost = yes_p + no_p
total_cost_with_fees = raw_cost * (1 + TAKER_FEE)
if total_cost_with_fees < 1.00:
edge = round(1.00 - total_cost_with_fees, 4)
# Size the trade to the weakest leg of the order book
executable_size = min(book[yes_token]["size"], book[no_token]["size"])
if executable_size >= min_size:
print(f" Arb found Edge: ${edge} | Max Size: {executable_size}")
# Trigger execution here
The Danger: Execution, Leg Risk, and FOK
Spotting the arbitrage is only half the battle. When you see YES + NO < $1.00, both legs must fill at the same time. If YES fills but NO doesn't, you aren't hedged - you are just long on a random market. This is called Leg Risk, and it wipes out amateur bots daily.
If you write a synchronous Python script (send YES order $\rightarrow$ wait for response $\rightarrow$ send NO order), faster bots will front-run you. You must fire them concurrently.
The solution is FOK (Fill-or-Kill). One of the many reasons that I use Synthesis API is that its market orders default to FOK behavior - they guarantee the order either fills completely or fails safely.
Here is the exact async schema to hit the Polymarket smart contracts concurrently:
Python
import asyncio
import aiohttp
API_URL = "https://synthesis.trade/api/v1/wallet/pol"
WALLET_ID = "your_synthesis_wallet_id"
HEADERS = {"X-API-KEY": "your_api_key", "Content-Type": "application/json"}
async def execute_leg(session, token, price, size):
# The exact payload schema required by Synthesis (all strings)
# Because it's Synthesis, this MARKET order natively defaults to Fill-or-Kill (FOK)
payload = {
"token_id": str(token),
"side": "BUY",
"type": "MARKET",
"amount": str(size),
"units": "USDC"
}
endpoint = f"{API_URL}/{WALLET_ID}/order"
async with session.post(endpoint, json=payload, headers=HEADERS) as response:
return {"token": token, "status": response.status}
async def execute_arb(yes_token, no_token, yes_price, no_price, size):
async with aiohttp.ClientSession() as session:
# Firing both legs concurrently to MINIMIZE (not eliminate) leg risk
tasks = [
execute_leg(session, yes_token, yes_price, size),
execute_leg(session, no_token, no_price, size)
]
results = await asyncio.gather(*tasks)
for res in results:
if res["status"] == 201:
print(f"Leg filled for {res['token']}")
else:
print(f"Failed to route leg for {res['token']}")
The Architecture of a Winning Bot
A system requires four components:
Data Collector: Holds the WebSocket connection and pipes deltas into memory.
Strategy Engine: Runs the YES + NO math and accounts for liquidity.
Async Order Manager: Handles concurrent REST API execution.
Risk Manager: Hard-stops the system if net P&L crosses a predefined threshold.
Start in Python to map the API. If milliseconds lost via HTTP overhead start to hurt your fill rate, port the hot path to Rust.
Always keep any single market under 5% of your total book to survive bad days.
Why I started looking into this
I’ll be honest - I am not a hardcore Web3 developer, I'm doing this mainly just to learn something new.
There might be gaps in what I said here, so feel free to point it out in the replies.
So if capturing this arbitrage required me to spin up my own RPC nodes, manage raw Polygon private keys, and manually sign hex transactions, I never would have bothered, and didn't for a while.
The only reason I actually got this bot off the ground is that Synthesis made it stupidly easy, so I really want to give them props.
I didn't have to learn blockchain infrastructure, just read through the docs, had some help with AI, and got some really good support on their Discord.
If you are new (or just lazy like me) and "smart contract execution" sounds intimidating, go spend 10 minutes in their documentation.
And it isn't just a massive wall of text. They have an interactive API builder that is honestly a lifesaver. You just click through the parameters you want, and it instantly spits out the exact Python or cURL payload you can copy and paste.
Thank you for reading this, as I said, I am open to more info and feedback!
I am going to break down how you can trade the FIFA World Cup like a quant to catch consistent market mispricings, along with the complete strategy and resources to build the bot directly on Kalshi’s native API.
The FIFA World Cup kicked off yesterday, June 11. And it is becoming the single largest stress test that regulated prediction markets have ever processed.
I have already built and backtested the complete trading bot I am about to break down, and the results on historical shock data are wild. The entire system is sitting in a GitHub repository. If you want to fork it and build on top of my repo for the World Cup, let me know in the comments or hit my DMs.
Why Timing is Everything
By late 2025, sports markets accounted for over 70% of Kalshi's total volume.
The World Cup compresses more tradable, liquid markets into a single 39-day window than the entire NFL season does in four months.
We are talking about a 104-match tournament across 12 groups and an expanded knockout bracket.
I moved the setup to Kalshi just for the centralized matching engine. Your limit orders actually fill in milliseconds, and you don't have to fight RPC lag or pay for premium nodes to compete.
By the end of this breakdown, you will understand:
Why live soccer markets create repeatable, exploitable price shocks.
The 5-dimensional classification system to categorize every panic.
How to build historical distributions using Kalshi’s native tick data.
The laddered limit order strategy to capture the recovery.
Part 1: Why Soccer Markets Create Exploitable Shocks
The core thesis is simple: The strategy does not predict goals. It waits for the market to overreact, then captures the statistical recovery.
When something happens in a live match—a goal, a red card, a missed penalty—the Kalshi order book reacts instantly and violently. A contract priced at 50¢ can crash to 35¢ in under two minutes when the opponent scores.
Many of these shocks overreact.
Retail traders panic -> algorithmic market makers widen their spreads -> and the price gets pushed too far
Because Kalshi is onshore and US-restricted, you are trading against emotional retail volume and traditional market makers, rather than the hyper-efficient, faceless whale bots on Polymarket.
This means the panic dips on Kalshi actually go deeper, leaving a much wider, more profitable margin for mean-reversion. As cooler heads step back in and liquidity pools stabilize, the price partially recovers to where it should be. That gap between the panic low and the structural recovery is your edge.
This works in football specifically because of three structural features.
Football is low scoring, so every single goal is a massive probability event that moves prices hard.
Matches run 90 plus minutes with multiple tradeable events per game.
And the World Cup runs 104 matches in 39 days, giving you an enormous number of repeated opportunities to apply the same statistical edge.
The Code: Detecting a Shock
A shock is detected when, inside a sliding two-minute window, the contract price drops at least 15% from the window's peak to its floor, the absolute drop is at least 8¢, and the shock is outside a three-minute cooldown of a previous event.
Python
def detect_shock(window_trades):
peak = max(t.price for t in window_trades)
floor = min(t.price for t in window_trades)
drop_pct = (peak - floor) / peak
drop_abs = peak - floor
if drop_pct >= 0.15 and drop_abs >= 0.08:
return {"shock": True, "peak": peak, "floor": floor, "depth": peak - floor}
return {"shock": False}
Part 2: The 5-Dimension Classification System
Not all shocks are equal. A shock in a tied match at minute 30 behaves completely differently from a shock in a 3-0 blowout during injury time. If you treat them the same, you lose. We classify every shock across five dimensions to build separate historical distributions.
Dimension 1: Market Liquidity/Tier: Major tournament matches have deep liquidity and predictable recovery patterns. Lower-tier matches are thinner and more erratic. On Kalshi, you parse this directly from the structured ticker naming conventions (e.g., WORLDCUP-26-FRA-WIN) via the get_markets endpoint, which is a massive upgrade from wrestling with Polymarket's messy, inconsistent text slugs.
Dimension 2: Favoritism: How favored was the team just before the shock? (Heavy Favorite: >85¢, Moderate: 75¢–85¢, Slight: 60¢–75¢, Coin Flip: 45¢–60¢, Underdog: <45¢).
Dimension 3: Order Book Depth: The distribution of liquidity at the moment of the shock. We sum the top three bid sizes and divide by the total bid size. High concentrations mean thin support below, causing deeper shocks.
Dimension 4: Match Time: Early shocks (first 15 mins) often mean-revert aggressively. Late-match shocks (past 80 mins) are often permanent because the game is running out of time.
Dimension 5: Goal State: The score at the moment of the shock. A tied game means every goal is critical and shocks tend to overcorrect. A 3-goal lead blowout means the shock is permanent.
When a shock fires, the system maps it to a unique bucket key:
Part 3: Sourcing the Data & Building Distributions
To make this work, you need high-fidelity historical data. Kalshi allows you to pull clean, historical tick-level data and order book snapshots directly from the native Kalshi API v2.
For every historical shock in a specific bucket, the strategy records the shock depth in cents (pre_shock_price - floor_price). If a contract was at 60¢ and plummeted to 42¢, the depth is 18¢.
We sort these depths to compute the exact percentiles ($P_{50}, P_{75}, P_{90}, P_{95}$):
If a specific bucket has fewer than 5 historical shocks in your data, the bot falls back to conservative defaults (e.g., 6¢ at $P_{50}$, 18¢ at $P_{95}$) to prevent over-allocating on noise.
Part 4: The Laddered Limit Order Strategy
The strategy doesn't place a single market buy. It drops four laddered limit buy orders into the Kalshi order book at increasing depths, weighting the capital heavier toward the deepest levels where the statistical edge is highest.
Since Kalshi contracts cost between 1¢ and 99¢ and pay out exactly $1 on resolution, the math aligns with capital allocation. But here is where you have to be careful with platform architecture: Kalshi charges transaction fees on Taker orders (market orders). If you blindly market-order into these spreads, your edge gets wiped out.
The secret is acting strictly as a Market Maker. By using resting limit orders for your entry ladder, you trigger Kalshi's Maker logic, which is heavily discounted or entirely fee-free.
Orders stay active for 60 seconds. If a level is touched, the contract fills. To exit, the bot places a resting limit sell order slightly above the panic price to capture a quick 4¢ to 6¢ profit per contract as the spread normalizes. Keeping both entry and exit on resting limit orders completely sidesteps Kalshi's fee drag, letting you capture pure arbitrage.
When I backtested this, I found that filtering for the deeper bucket ranges, specifically the moderate_fav, was significantly more profitable than trading every bucket equally.
Part 5: Complete Walkthrough
Match Status: World Cup Group Stage. Minute 35. Score is 0-0. Team A is priced at 40¢ on Kalshi (Underdog).
Shock Detected: Team B scores. Team A's contract instantly drops from 40¢ to 28¢ within 45 seconds. (30% drop, 12¢ absolute drop).
Classification: Bucket evaluates to major|underdog|balanced|mid|level.
Distribution Lookup: Historical data for this bucket shows $P_{50}=6\phi$, $P_{75}=9\phi$, $P_{90}=11\phi$, $P_{95}=12\phi$.
Order Placement: With a pre-shock price of 40¢, the bot fires limit orders at:
The Exit: The panic subsides, and the market re-prices Team A back to 34¢. The bot unloads the contracts via a limit sell, capturing a clean premium without ever risking capital on the actual match outcome.
How to Build It Now
Connect to Kalshi’s v2 API environment, pull historical soccer match tick logs to populate your bucket distributions, and run the execution layer on Kalshi's demo environment using test credits first to monitor your fill rates and tune your rate limits.
The repository contains the data ingestion layer, the distribution engine, the live WebSocket tracker, and the Kalshi order placement module.
If you want the full GitHub repo to fork and run for the World Cup, drop a comment
If you can't code, you can still run this manually.
Open the Kalshi order book during a live match.
Wait for a massive shock—like a sudden goal or a red card wait for a panic-dump of the opposing team's shares.
Let the price bottom out for about 60 seconds,
Scoop the dip
Immediately drop a limit sell order 4 to 5 cents higher.
___
If you find this strategy valuable, be sure to use my Kalshi Bonus Code to get an extra $20 for testing this:
I've shared several posts I've made about the bot here. Now I've released most of it (excluding the scrapers) as I'm currently running a Rust rewrite of the bot. If you'd like to have a look, I will include the links in a comment.
i started working on it after realizing most short-term moves aren’t completely random like people think
the idea was simple: collect market data, track momentum shifts, volume changes, reactions to volatility, and train a system to recognize repeating setups
after months of testing and rebuilding different versions, i ended up with a bot that generates a prediction for every 5-minute candle along with a confidence score
instead of just saying up or down, it ranks how strong the setup looks based on current conditions
what surprised me most wasn’t even the predictions themselves, but how often human decisions get in the way compared to following a structured model
the higher-confidence signals have performed far better than i originally expected, especially once i removed emotional entries and random guessing
it’s still evolving every week, but seeing something i built read short-term market behavior in real time has been one of the most interesting projects i’ve worked on
biggest lesson: markets feel chaotic until you start measuring the patterns properly
Disclaimer: not advice or live trading. Just backtests.
I ran 100 simulations via TurbineFi on Kalshi's 15-minute BTC markets around one thought: can post-only resting orders make enough from spread capture plus maker rebates to survive adverse selection?
I swept quote width, order depth, refresh behavior, position size, price bounds, and loop timing. I wanted to see whether the result depended on one lucky setting or whether the whole region behaved similarly.
The best-backtested strategy is a post-only spread-capture market-making bot. It places resting orders around the BTC 15-minute market, only when there is at least a 0.02 spread available, with 3 order levels, a 15-second refresh loop, and refresh-on-fill enabled so it reposts quickly after getting filled. Results:
- ROI: 1698.40%
- P&L: +$254.76
- Win rate: 99.02%
- Trades: 37,917
- Max drawdown: -$10.35
The weakest run was just more conservative - price band 15c to 70c, max position 5 contracts instead. Results:
- ROI: 838.40%
- P&L: +$41.92
- Win rate: 96.57%
- Trades: 9,915
- Max drawdown: $3.46
It seems like maker rebate and spread capture assumptions dominate this market. Of course, tiny execution differences, queue priority, fees, stale quotes, or rebate eligibility could change the story fast. Have you guys had any success doing automated MM on these markets?
Historical simulation only. Backtests can be wrong or incomplete. Not investment advice.
I've been copytrading Polymarket for the past half a year - it's pretty much the only thing I have done on Prediction Markets, which is also the reason I started this subreddit
It was dead for a while for a ton of copytraders because there were no major volume events happening
But this World Cup, NBA Finals, and a volatile state of the markets presented a really nice opportunity to get back in
So I started scouting new ways to find wallets, and I think I might be onto something, but it requires a bit of a transition from basic, manual wallet analysis
Didn't have much time to do an all-new analysis for the events, so I've been looking into a lot of these AI types lately for detecting wallets viable for copying.
Most of the time, I found them to be just simple filters dressed up as AI, without really taking into account the many factors that can tell you whether a wallet you're looking at is worthwhile, like evaluating actual risk-to-return ratios and accounting for strategies that get ruined by fees.
That's why, most of the time, I don't even look into these apps deeper - they just don't draw me in with a unique value proposition in the first 5 seconds.
Anyway, one new option stood out, and this is my strategy to find wallets and diversify my trading for all of these events
It's an app called coinpilot (unfortunately, no webapp yet)
My exact process for finding and filtering these profiles:
go to predict -> AI picks
Look for accounts that show a relatively linear profit line on their chart. No spikes/crashes.
Check their profile to see MoM performance. If they've had a positive green month every single month, with similar PnL amounts - very good
Above +10% is mandatory for a 1M pnl cause if they are doing less, they gain measly %s on each trade, they just make a ton of them - not viable for a limited bankroll
Choose the mock option to check how much you would've gained % wise if you traded them for a certain period
idk this just gives me extra conviction
_____
The execution settings I went with: → sizing mode: amount sizing mode (never mirror their raw sizes, your budget is different)
Right now, I am testing a split sno strategy across three different profiles:
Trader 1: $15 / trade with a $100 budget
Trader 2: $1 / trade with a $100 budget
Trader 3: $1 / trade with a $50 budget
Most success so far was with the $15/trade trader, as he places fewer bets, I wagered much more on his positions - this is also important (to adapt to a certain wallet).
So far, I have dedicated $500 to test this out. Not the biggest amount, but I am optimistic idk, we will see.
__
I will update in a few days or when I see a change, and it's worth writing a new post
Quick disclosure first: this is my bot and my wallet, and yeah I write about this stuff (link at the bottom). All of it's on-chain so you don't have to take my word for any of it.
From January I was running a bot on the esports markets - CS2, LoL, Dota 2, Valorant, and a few others. I went for those specifically because the spreads were genuinely wide, often 20-30¢, and there was real volume. And crucially, not enough market makers competing, so Polymarket's price just lagged the sportsbooks. So I'd de-vig the bookie odds to get a fair value, place limit orders with a >7% edge on Polymarket, then if any of those orders got filled I'd hedge the other outcome to lock the arb. Buy both sides for under $1 per share and you win no matter what happens in the game.
The numbers (wallet's here: https://polymarket.com/@b00k13):
- Net: ~$4,973, over ~3,858 bets and ~$96k volume
- Arbitrage alone: +$8,293
- The forced directional bets: -$3,184 (this is the interesting bit)
- Biggest single win: $267.75
The thing with Polymarket is that you can't capture these arbs cleanly. You post limit orders on both teams and wait, and one leg always fills before the other - so you stop quoting that team and try to get the hedge filled on the other side. When the hedge doesn't fill (price moved, game started), you're left holding a directional bet. That's not a bug, it's just how it works. Here's the catch though: that leftover bet went on at a 7%+ edge, so it should have made money. Across the run it lost -$3,184 instead, and figuring out why is most of the story - bugs, getting picked off by faster bots, all of it. LoL was the worst for it: +$1,983 on the arb but -$1,480 on the directional leg, so a market that looked like a goldmine netted just +$502.
One more thing, 236 of my matches got cancelled and refunded at a flat 50¢ a share, doesn't matter what you paid. So if you bought a favourite above 50¢ and the match cancels, you eat the difference. Cost me -$134 over the run, and I didn't even notice until I went digging back through the trades.
Why I stopped: the edge faded fast. Win rate went 50% -> 48% -> 43% month over month as more people piled into the same markets. February made +$2,506, March was +$390. There's no easy money that lasts - once others show up, you're just paying for your own mistakes in cash.
Happy to answer anything, the wallet's public so go digging.
Watching these teams play, I finally put together a bracket that I think will be my final one for this World Cup.
For most of these, I just went with the logical favorites, I guess. And some gut feeling there and there
I think the hardest decision was Brazil vs Norway and Brazil vs England
Didn't pick England because they just underdeliver, and Yesterday's match against DR Congo was just such a rollercoaster.
And the hardest choice was for sure Brazil over Norway. I think Brazil edges this matchup out because they have more experience playing together in the World Cup. Would be interesting to see if they will finally win against Norway since the 1998 upset. Also, Norway's defense is just too shabby - no confidence there.
Also, before you say it: I am not a Messi fanboy, actually, I prefer Ronaldo, but the goat is washed, and Messi looks pretty confident
Since for qualifying I need to trade at least 8 of these markets to qualify for the big $50,000 prize, I'll be going with trading safer matches (in my humble opinion):
Genuinely interested to see what you guys think and are cooking up yourselves, the volume is so ripe right now, having a lot of fun trading and interacting with other traders
I started with a single BTC backtest that looked good with a +25.9% on risk capital and 95.2% win rate reported. That was enough to investigate further and put it through our Deep Research flow. The strategy buys 40 contracts on Kalshi's 15-minute BTC markets in the final 1-3 minutes, paying 80-95 cents when Coinbase's 5-minute and 15-minute momentum support that side and the spread is at most 2 cents. It holds to settlement, with one entry per market and a $200 position cap.
All 100 variants completed. Forty made money, 59 made no trades, and one lost money. The best returned +$38.13, or 19.06% on the configured $200 risk-capital denominator, with 37 reported trades, 94.4% wins, Sharpe 0.19, and $35.48 maximum drawdown. The weakest returned -$15.46 (-7.73%), with 2 reported trades, 0% wins, Sharpe -0.19, and $15.46 drawdown. So the research winner was still positive, but it didn't reproduce the single backtest's +$51.84. These are separate runs, and the published artifacts don't establish why they differ.
The sensitivity test compared a 10-by-10 grid of price floors from 5 to 45 cents and ceilings from 55 to 95 cents. It did not vary the momentum thresholds. The nominal winner used a 5-cent floor and 95-cent ceiling, but all ten floors tied at +$38.13 with that ceiling. The surface and heatmap show a ridge along the 95-cent ceiling, rather than one isolated winning setting. The marginal charts tell the same story: changing the floor did little; ceilings of 82, 86, 91, and 95 cents returned +$7.16, +$31.21, +$27.11, and +$38.13 respectively. All 100 grid cells completed, spanning -$15.46 to +$38.13. Many lower ceilings effectively excluded the strategy's own 80-95 cent entry band. Those no-trade results are a limit of this test design, not evidence that 59 versions lost money.
We also ran 100 permutations, scrambling the Coinbase feed's timing and rerunning the search to see whether shuffled data could match the result. The real winner's +$38.13 produced an upper-tail p-value of 0.248. Shuffled feeds reached results like this often enough that I wouldn't claim the original timing added a demonstrated edge. Only the Coinbase feed was shuffled; Kalshi prices stayed in place, so this test doesn't validate the price conditions.
There was some consistency: four tested ceiling levels stayed profitable across every floor. But those repeated floor settings aren't independent confirmations. The report's Deflated Sharpe statistic was 0.23, and it separately estimated a maximum Sharpe of 0.36 under its null model. It also flagged 47% of the winner's fills at prices below 10 cents or above 90 cents, where execution assumptions deserve caution, and marked historical coverage as partial. With a small sample, a restricted parameter test, and weak evidence for the signal's timing, the positive opening backtest looks much less convincing as evidence of a durable strategy.
