• Why PolyEdge
• The Four Strategies
• Platform Features
• Getting Started for Traders
• Choosing Traders to Copy
• Subscription Tiers
• Tech Stack
• Architecture
• Developer Quick Start
• Deployment
• Key API Routes
• FAQ
• Contact
• Risk Disclaimer
• License

Polymarket is one of the most liquid prediction markets in the world, and its order book is inefficient enough to trade systematically — prices drift, both sides of a binary market occasionally sum to less than $1, and a handful of traders consistently beat the market. PolyEdge turns those inefficiencies into four push-button strategies:

Every strategy runs in Paper (dry-run) mode first — simulated fills against live order books — so you can validate an edge with zero capital at risk before flipping a single switch to go live.

Follow one or more Polymarket wallets and automatically mirror their new entries in real time.

• Real-time mirroring — polls target wallets and copies new positions within seconds.
• Your sizing, not theirs — fixed-dollar or proportional copy, with min/max trade size, max position size, and a total-exposure cap.
• Smart filters — odds range, minimum liquidity, market category, and trading-hours windows.
• Minimum-size handling — automatically bumps an order up to Polymarket's minimum share size (and skips, with a clear reason, when it can't fit your limits) instead of silently failing.
• "Not Copied" transparency feed — every skipped, rejected, or paused trade is shown with a plain-English reason (e.g. "Order didn't fill — price moved", "Below market minimum"), plus a one-click Retry to buy into a still-open market.
• Auto-settlement — closes copied positions at the true 1/0 payout when a market resolves.

Within a single binary market, if best_ask(YES) + best_ask(NO) < $1, you can buy one share of each for less than a dollar. Exactly one outcome resolves to $1, so a balanced set returns $1 guaranteed — locking in 1 − Σ(asks) − fees with no directional risk.

• Continuously scans the most liquid markets and ranks them by net edge after modeled fees.
• Fill-or-Kill, at-ask execution — each leg fills at the price the edge was computed on or cancels cleanly, so a thin edge can never be slipped into a loss.
• Leg-balance protection — if one leg fills and the other doesn't, the bot unwinds the orphan leg so it never holds a naked directional position; any residual is reconciled to equal size.
• Live watchlist + per-market YES/NO charting on the dashboard.

Protect open positions by taking a calibrated opposite-side position — lock in a minimum profit once a position moves in your favor, or cap the loss if it moves against you. Configurable hedge ratio, profit-lock threshold, and stop-loss.

Quote passively on both sides of a market to capture the bid/ask spread and earn Polymarket's liquidity rewards, with inventory limits and automatic re-quoting as the book moves.

• Paper & Live modes — every bot simulates against live order books before you risk capital; switching modes is gated so you can't accidentally mix the two.
• Mark-to-market portfolio — open positions priced against the live CLOB midpoint with real unrealized PnL, PnL %, a cumulative-PnL equity curve, per-bot allocation, and win rate.
• Leaderboards — live-only rankings so you can scout which traders (and which bots) are actually making money.
• TradingView charts — live YES/NO price charts with your bot's own fills marked.
• Sign-In With Ethereum — passwordless wallet auth (SIWE) via NextAuth.
• Multi-chain crypto payments — subscribe with ETH, Polygon, BSC, or Solana.
• Dedicated worker process — bot poll loops + payment monitoring run in a separate process from the web server for latency isolation and resilience.
• Risk controls — exposure caps, daily-trade limits, consecutive-failure breakers, and trading-hours windows on every strategy.

No installation required — PolyEdge runs entirely in your browser at polyedge365.com. Here's how to go from zero to your first bot in minutes:

1. Connect your wallet — Open polyedge365.com and sign in with Sign-In With Ethereum (SIWE). No password, no email signup — your wallet is your account. Nothing is signed that moves funds; it's a free signature to prove ownership.
2. Start in Paper mode — Every bot opens in Paper (dry-run) mode by default. Your trades are simulated against the live Polymarket order book, so you see realistic fills, slippage, and PnL with zero capital at risk.
3. Configure your strategy — Pick a bot (Copy, Arbitrage, Hedge, or Market Making) and tune it: sizing, exposure caps, odds filters, trading-hours windows, and stop-losses. Sensible defaults are pre-filled so you can launch immediately and refine later.
4. Run & watch — Hit Start. The dashboard streams live fills, an equity curve, win rate, and a transparent activity feed explaining every action the bot takes (including why it skipped a trade).
5. Go live when you're ready — Once a strategy proves out on paper, add your Polymarket CLOB credentials under Settings → API Keys (encrypted at rest), choose a subscription tier, and flip the bot to Live. Start with small size limits and scale as your confidence grows.

Paper and Live never mix. Mode switching is gated, so you can't accidentally fire real orders while testing — and you can always drop back to Paper to experiment.

The copy bot is only as good as the wallets it follows. Pick traders from verified, live data — never from a static list (today's hot trader can be tomorrow's blow-up). Two reliable sources:

1. Polymarket's official leaderboard — polymarket.com/leaderboard Ranks every wallet by realized profit and volume over 1D / 1W / 1M / All-time. Copy a wallet address straight into the bot's Target Wallets setting.
2. PolyEdge's own leaderboard (/leaderboard) — live-only PnL rankings of platform users and bots.

What to look for before following a wallet:

Start in Paper mode with a candidate wallet for a few days. If the simulated PnL holds up, graduate to Live with small size limits and scale from there.

┌─────────────────┐        ┌──────────────────────────┐
│   Web process   │        │   Bot worker process      │
│   (Next.js)     │        │   IS_BOT_WORKER=true      │
│                 │        │                           │
│ • Dashboard/UI  │        │ • Copy / Arb / Hedge / MM │
│ • API routes    │  ⇄ DB  │   poll loops (reconciler) │
│ • Auth, charts  │        │ • Payment monitor         │
│ • One-off       │        │ • Settlement on resolution│
│   actions       │        │                           │
└─────────────────┘        └──────────────────────────┘
        │                              │
        └──────────► Polymarket CLOB / Gamma / Data APIs

The web process serves the UI and delegates all bot execution to the worker (COPY_BOT_RUNTIME=worker) so the two never double-execute orders.

app/
  (marketing)/       Landing, pricing, public leaderboards
  (dashboard)/       Bot dashboards (terminal, performance, settings), portfolio
  api/               auth · bot/[type] · portfolio · payments · markets
components/
  bots/              Config forms, live charts, activity & "Not Copied" feeds
  ui/                Design-system primitives
services/
  bots/              Copy / Arb / Hedge / Market-Maker engines + reconcilers
  copy-trading/      Engine, executor, portfolio marks, settlement
  arb/  hedge/  market-making/   Strategy engines + executors
  polymarket/        CLOB / Gamma / Data API clients
  payments/          On-chain processor + monitor
lib/                 Auth, encryption, Polymarket CLOB auth, config helpers
prisma/              Schema (User, BotConfig, Trade, Subscription, Payment, …)

Most users never need this — just head to polyedge365.com. This section is for self-hosting or local development.

Prerequisites: Node.js 20+, PostgreSQL 14+.

# 1. Install
npm install

# 2. Configure — copy the example env and fill in values
cp .env.example .env
#    DATABASE_URL, NEXTAUTH_SECRET, ENCRYPTION_KEY, RPC URLs, etc.

# 3. Database
npx prisma generate
npx prisma db push

# 4. Run the web app (http://localhost:3210)
npm run dev

To run the bot worker locally (executes the poll loops + payment monitor):

IS_BOT_WORKER=true COPY_BOT_RUNTIME=worker WORKER_PORT=3211 npm run dev

Live trading requires CLOB credentials. Add your wallet private key and Polymarket API credentials under Settings → API Keys. Keys are encrypted at rest (ENCRYPTION_KEY). Until then, every bot runs safely in Paper mode.

Bots run in a dedicated worker; the web process delegates to it. Always stop the servers before building — building .next while a server is serving it tears chunks.

# Stop both processes, then:
npm run build

# Web (delegates bot loops to the worker via COPY_BOT_RUNTIME=worker in .env)
npm start                                   # port 3210

# Worker (owns all bot loops + payment monitor)
IS_BOT_WORKER=true COPY_BOT_RUNTIME=worker WORKER_PORT=3211 npm start -- -p 3211

Put a reverse proxy (nginx) in front of :3210 with TLS. Ensure COPY_BOT_RUNTIME=worker is set in .env so the web process never runs bot loops alongside the worker.

Prices are overridable via NEXT_PUBLIC_BOT_PRICE_<TYPE> env vars.

Do I need to install anything to use PolyEdge? No. The platform is live at polyedge365.com — connect your wallet and start in Paper mode. This repository is only needed if you want to self-host or develop locally.

Is my money or private key ever at risk? Sign-in uses a free SIWE signature that moves no funds. Live trading requires you to add Polymarket CLOB credentials, which are encrypted at rest (ENCRYPTION_KEY). You stay in full control of your wallet and can run indefinitely in Paper mode without ever entering live credentials.

Is the arbitrage really "risk-free"? The strategy is market-neutral at resolution — buying YES + NO for under $1 locks in a payout of exactly $1. The residual risks are execution (a leg not filling), fees, and liquidity, which the bot mitigates with Fill-or-Kill, at-ask execution and leg-balance unwinding. See the Risk Disclaimer.

Which traders should I copy? Pick from live, verified data — never a static list. See Choosing Traders to Copy for the exact signals to look for.

What does it cost? Each bot has its own subscription tier — see Subscription Tiers. Subscriptions are paid in crypto (ETH / Polygon / BSC / Solana).

Can I run more than one bot at a time? Yes. Bots run independently with their own configs, exposure caps, and PnL tracking, and the portfolio view marks them all to market together.

Questions, support, or partnership inquiries — reach out through any of the channels below:

PolyEdge is trading software, not financial advice. Prediction markets carry real risk and you can lose money — including with strategies described as "risk-free" if execution, fees, liquidity, or market resolution behave unexpectedly. Past performance of any trader or strategy does not guarantee future results. Always start in Paper mode, trade only what you can afford to lose, and comply with the laws and Polymarket's terms of service in your jurisdiction. You are solely responsible for your trades and your keys.

MIT — see LICENSE.