DEV Community: Manpreet Brar

I built in-app Polymarket copy trading with MetaMask EIP-712 — no private keys, no redirects, one click

Manpreet Brar — Sun, 02 Aug 2026 21:40:08 +0000

I just shipped one-click copy trading on WhaleTrack — here's
the architecture that makes it work without ever touching a
private key.

The Problem

Polymarket's CLOB API needs two auth layers:

EIP-712 order signing
HMAC-SHA256 HTTP auth

Most tutorials store private keys server-side. That's a
security nightmare.

The Solution — Split Architecture

Backend builds the unsigned order + fetches live price
MetaMask signs EIP-712 typed data client-side
Backend attaches HMAC headers and proxies to CLOB

The user's private key never leaves MetaMask. Ever.

The Flow

Step 1 — Fetch unsigned order params
\

const res = await fetch(`/api/trade-params?slug=${slug}
  &outcome=${outcome}&amount=${amount}&address=${address}`);
const { domain, types, order } = await res.json();
\```



**Step 2 — MetaMask EIP-712 sign**
\

```js
const signature = await window.ethereum.request({
  method: 'eth_signTypedData_v4',
  params: [address, JSON.stringify({ domain, types, 
    primaryType: 'Order', message: order })]
});
\```



**Step 3 — Backend HMAC proxy**
\

```js
const message = timestamp + 'POST' + '/order' + body;
const secret  = Buffer.from(apiSecret, 'base64');
const sig     = crypto.createHmac('sha256', secret)
                      .update(message).digest('base64');
\```



## Result

See whale bet → click Copy Bet → sign in MetaMask → 
order on Polymarket. Under 60 seconds.

Connect via MetaMask wallet or Polymarket API key.

👉 whaletrack.app — free, no signup

Would love feedback from devs on the architecture. 
What would you do differently?

How I built an automated YouTube video pipeline for my SaaS using Python, edge-tts, and moviepy

Manpreet Brar — Sun, 26 Jul 2026 22:14:20 +0000

How I built an automated YouTube video pipeline for my SaaS using Python, edge-tts, and moviepy

I run a niche tool called WhaleTrack (whaletrack.app) — it tracks big bets on Polymarket in real time.

To grow it I decided to start a faceless YouTube channel. No camera, no editing software, no designer. Just code.

Here's the full pipeline I built in one day.

The stack

edge-tts — Microsoft's neural TTS (Andrew voice, free, no API key)
moviepy 1.0.3 — video assembly
Pillow — image processing
Puppeteer — screenshot the live website
ffmpeg — underlying encoder

Step 1: Screenshot the real website

Instead of fake mockups I screenshot the actual live site using Puppeteer:


js
const puppeteer = require('puppeteer');
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.setViewport({ width: 1920, height: 1080 });
await page.goto('https://whaletrack.app');
await page.screenshot({ path: 'screenshots/home.png' });

Gotcha: if your package.json has "type": "module", Puppeteer's require() breaks. Name the file .cjs not .js.

Step 2: AI voiceover

import edge_tts
comm = edge_tts.Communicate(script, voice='en-US-AndrewNeural', rate='+8%')
await comm.save('audio.mp3')

Completely free. Sounds genuinely good. Andrew Neural is the best voice I found for this style of content.

Step 3: Ken Burns effect
Static screenshots are boring. This adds a slow zoom + pan to make it feel like real video:

def apply_ken_burns(img, progress, zoom_from, zoom_to, pan_from, pan_to):
    zoom = zoom_from + (zoom_to - zoom_from) * progress
    iw, ih = img.size
    crop_w, crop_h = int(iw / zoom), int(ih / zoom)
    ox = int(pan_from[0] + (pan_to[0] - pan_from[0]) * progress) * (iw - crop_w)
    oy = int(pan_from[1] + (pan_to[1] - pan_from[1]) * progress) * (ih - crop_h)
    return img.crop((ox, oy, ox + crop_w, oy + crop_h)).resize((1920, 1080), Image.LANCZOS)

Step 4: Assemble with moviepy

from moviepy.editor import VideoClip, AudioFileClip

def make_frame(t):
    progress = t / duration
    frame = apply_ken_burns(bg_image, progress, 1.0, 1.12, (0,0), (0.03,0.02))
    return np.array(frame)

clip = VideoClip(make_frame, duration=duration)
clip = clip.set_audio(AudioFileClip('audio.mp3'))

Result

A 2.6 minute 1080p YouTube video, fully automated, from a Python script.

Total cost: $0. Total time to build the pipeline: ~1 day.

The video: https://youtu.be/iwGwUpbhABA
The tool: https://whaletrack.app

Happy to share the full script if anyone wants it. Building in public — follow along if you're into niche tools + automation.

How I Added a Premium Telegram Alert Bot to My Polymarket Whale Tracker — And Why Speed Is the Product

Manpreet Brar — Sat, 18 Jul 2026 14:17:32 +0000

I built WhaleTrack a few weeks ago — a live dashboard that tracks the biggest wallets on Polymarket. Got some good traction, a few hundred users, and a free Twitter bot posting whale alerts automatically.

Then someone asked me: "Why would I pay for this when you're posting the same data for free on Twitter?"

Fair question. It made me rethink what the product actually was.

The Problem With Twitter Alerts
The Twitter bot works fine. It detects a whale trade and posts within the next 5-minute polling cycle. But here's the thing — by the time it posts, the window is already closing.

Polymarket is liquid. If a whale drops $50K on a market and moves the price, people who see the tweet 20 minutes later are buying into an already-shifted market.

Speed is the product. Not the data.

Free users get the data. Premium users get it first.

The Architecture
Zero npm dependencies — same as the first article. Pure Node.js with the built-in https and crypto modules.

The bot uses long polling instead of webhooks:

async function poll() {
while (true) {
try {
const data = await fetchJson(
https://api.telegram.org/bot${BOT_TOKEN}/getUpdates?offset=${offset}&timeout=30
);
for (const u of (data.result || [])) {
offset = u.update_id + 1;
const msg = u.message;
if (msg?.text?.startsWith('/')) {
handleCommand(msg.chat.id, msg.text);
}
}
} catch (e) {
await new Promise(r => setTimeout(r, 5000));
}
}
}
Long polling holds the connection open for 30 seconds waiting for updates, then immediately reconnects. No webhooks needed, no server config, works fine from a Mac running 24/7.

Two Alert Tiers
Every whale trade fires two alerts — premium first, free after.

Free alert:

🐋 Whale Alert!
somalianKing just bought
🟢 Yes $47K @ 62¢
📊 Will Argentina win the World Cup?
🔓 Get win rate + instant alerts → upgrade to Premium
🌐 whaletrack.app
Premium alert (fires first):

⚡ PREMIUM Whale Alert
somalianKing just bet $47,000
🟢 Yes @ 62¢
📊 Will Argentina win the World Cup?
🐋 This whale's track record:
• Rank: #3 on Polymarket
• Total P&L: +$284K
• Win rate: 71% (34 resolved trades)
🎯 Copy this bet on Polymarket →
⏱ You're seeing this 10+ min before Twitter
The premium alert has three things free doesn't: win rate, P&L context, and a direct affiliate link to copy the bet.

The Win Rate Calculation
This was the interesting part. Polymarket doesn't give you a clean "won/lost" field on activity records — you have to infer it from sell prices.

The logic:

Fetch last 50 trades for a wallet
Filter for SELL transactions only
Sold at ≥ 0.85 = win (exited near $1 resolution)
Sold at ≤ 0.15 = loss (exited near $0 resolution)
Everything in between = position still live or unclear
async function fetchWinRate(address) {
const activity = await fetchActivity(address, 50);
const sells = activity.filter(t => t.side === 'SELL' && parseFloat(t.price || 0) > 0);

let wins = 0, losses = 0;
for (const t of sells) {
const price = parseFloat(t.price || 0);
if (price >= 0.85) wins++;
else if (price <= 0.15) losses++;
}

const total = wins + losses;
return total > 0 ? Math.round((wins / total) * 100) : null;
}
I cache the result for 30 minutes per wallet since it's an expensive-ish call (50 activity records per whale).

Premium Subscriber Management
Kept it dead simple — a JSON file on disk.

let premiumSubs = loadJson(PREMIUM_SUBS_FILE, []); // [chatId, chatId, ...]
When someone pays (manually verified for now), I run /addpremium in my own chat with the bot. It adds them to the array, saves the file, and sends them a welcome message.

No Stripe, no database, no webhook. Works fine at this scale.

The Speed Advantage in Practice
The polling cycle runs every 5 minutes. Premium fires at the top of the cycle. Free fires at the bottom — after premium has already been delivered.

In practice this means premium users see alerts 5–10 minutes before the Twitter bot posts, and 10–20 minutes before anyone on Twitter actually sees it and acts on it.

On a fast-moving market, that gap matters.

What I Learned

Speed is a real value prop. Not "more features" — just faster. Simple to understand, easy to sell.
Long polling is underrated. Webhooks need a server with a public URL and SSL. Long polling works from anywhere. For a side project, that simplicity is worth it.
Keep the free tier genuinely useful. The free alert is still real value. Premium isn't a paywall on the core product — it's an upgrade on timing and context. That distinction matters for trust.
Manual premium management is fine at the start. Don't build Stripe until you have 10 paying customers. A JSON file is enough to validate demand.

What's Next
Proper payment flow (Stripe or Gumroad)
Filter premium alerts by whale win rate threshold (only fire if whale is 60%+ win rate)
Web dashboard showing premium-only whale analytics
Bot is live at @WhaleTrackBot on Telegram. Free tier available, premium is $9/month.

Live site: whaletrack.app

Happy to answer questions about the Telegram API, win rate logic, or the alert architecture.

How I built a real-time whale tracker for Polymarket using their public API

Manpreet Brar — Mon, 13 Jul 2026 01:45:00 +0000

Polymarket has a public data API that almost nobody talks about. I used it to build WhaleTrack — a live dashboard that tracks what the biggest traders on the platform are betting on.

The stack:

Vanilla JS frontend (no framework — just fast)
Vercel serverless functions to proxy all API calls (avoids CORS, keeps keys server-side)
Polymarket's data-api.polymarket.com for positions, leaderboard, and activity
The interesting parts:

The win rate calculation was tricky. Polymarket doesn't give you a clean "won/lost" field. You have to infer it:

redeemable === true = won (market resolved in their favour)
currentValue === 0 && redeemable === false = lost
Everything else = still open
Also learned the hard way that slug (market-level) and eventSlug (event-level) are different things on Polymarket. Market slugs 404 on polymarket.com/event/. Took me longer than I'd like to admit to figure that out.

Live at whaletrack.app — open to questions about the API or architecture.

How I built a real-time whale tracker for Polymarket using Node.js and a CLI

Manpreet Brar — Sun, 05 Jul 2026 03:05:29 +0000

The 2026 World Cup has $3.89 billion bet on it across Polymarket. That's not retail money — that's whales.

I built WhaleTrack to track exactly what those big wallets are doing. Here's the stack:

Backend: Node.js server fetching live data via Bullpen CLI
Frontend: Vanilla JS, real-time updates
Data: Polymarket CLOB API via Bullpen
Analytics: Google Analytics for traffic tracking
The hardest part wasn't the code — it was getting users. Pure SEO and content distribution (Reddit, Twitter, IH).

The site is live at whaletrack.app — would love feedback from devs on the UX and performance.

Happy to open source parts of it if there's interest.

How I Built a Real-Time Whale Tracker for Polymarket in a Weekend

Manpreet Brar — Sun, 28 Jun 2026 18:05:09 +0000

Prediction markets just hit $3.6B in volume. I wanted to know what the biggest traders were betting on — in real time. So I built WhaleTrack.

Here's how it works under the hood.

The Problem

Polymarket has a public leaderboard. But it only shows P&L totals — not what whales are currently betting on, not their recent activity, not their win rate. If you want to follow smart money, you're flying blind.

I wanted something that answered: what are the top traders doing right now?

The Stack

Vanilla JS frontend (no framework, keeps it fast)
Vercel serverless function as a backend proxy (avoids CORS issues)
Polymarket's public data API — no auth required

Step 1: Finding the Whales

Polymarket exposes a leaderboard endpoint:

https://data-api.polymarket.com/v1/leaderboard?limit=20

This returns traders ranked by P&L. I pull the top 10, grab their wallet addresses, and that's my whale list.

Step 2: Fetching Live Activity

For each whale wallet, I hit:

https://data-api.polymarket.com/activity?user={address}&limit=20

This returns their recent trades — market name, size in USDC, timestamp. Refreshes every 60 seconds.

Step 3: Calculating Win Rate (the tricky part)

The key is the redeemable flag — redeemable: true means they won, currentValue: 0 + redeemable: false means they lost. Took a few wrong attempts with cashPnl (always negative, not useful).

Step 4: The Whale Alert Banner

Every 60 seconds I check for trades over $5,000 placed in the last 10 minutes. When it fires, a green banner slides down with the whale name, market, and amount. Auto-dismisses after 12 seconds. First time I saw it fire live with a $28K bet — genuinely exciting.

Results

129+ users in the first few days
Zero ad spend
Traffic from Twitter, Reddit, Quora

What's Next

More whale wallets (suggestions welcome)
Click-through to open the same market on Polymarket directly
Email/push alerts for big trades

Check it out: whaletrack.app

All feedback welcome — especially if you spot a whale I'm missing.

I built a free whale tracker for Polymarket — here's what I learned

Manpreet Brar — Sat, 27 Jun 2026 03:16:11 +0000

The problem: I kept missing big moves on Polymarket because I had no way to see what the biggest traders were betting on in real time.

So I built WhaleTrack — a free, no-signup tool that shows you exactly what top Polymarket whales are buying and selling.

What it does

Live whale activity feed — see the last 40 trades from top wallets, updated on refresh
Whale leaderboard — P&L, win rate, trade count for the biggest accounts
No login, no ads, no fluff — just the data

How it works

The whole thing is vanilla HTML/CSS/JS deployed on Vercel with two serverless functions:

/api/whales.js — hits the Polymarket leaderboard API, fetches position stats for each whale, calculates win rates from closed positions

/api/activity.js — pulls recent trades for each whale wallet in parallel, filters out internal combo transactions (no title / zero price), and returns the 40 most recent trades

The serverless layer solves CORS — Polymarket's data API doesn't allow browser requests, so everything goes server-side.

Tech stack

Frontend: Vanilla HTML/CSS/JS (zero dependencies)
Backend: Vercel serverless functions
Data: Polymarket public data API
Deploy: Vercel (free tier)

Biggest lesson

Filtering bad data is half the work. The raw API returns combo trades and internal transactions that show up as "Unknown Market @ 0¢" — useless noise. Had to figure out which fields to check (title, price > 0) to strip them.

Also: win rate calculation is tricky when most whales have unrealized profits. Showing "—" instead of 0% is more honest.

Try it

WhaleTrack →

Also launched on Product Hunt today if you want to show some love: Product Hunt

Built this in a weekend. Happy to answer questions about the Polymarket API or Vercel serverless setup.