Why Polymarket Halted Trading After a Third-Party Breach Drained Millions

Why Polymarket Halted Trading After a Third-Party Breach Drained Millions

You can spend years auditing smart contracts and hardening cryptographic custody, yet still lose millions because a website speed tracker went rogue. That exact blind spot hit Polymarket on October 29, 2026. Within roughly 45 minutes, attackers siphoned over $2.6 million from active user accounts on Polymarket.com, forcing the prediction market giant to slam the brakes on international trading and freeze its relayer operations.

If you're looking for what actually went wrong, here's the short answer. Nobody cracked Polygon's blockchain, and nobody guessed a single seed phrase. Hackers compromised a third-party performance monitoring vendor, swapped a routine analytics script for malicious JavaScript, and hijacked the active browser sessions of logged-in traders. Polymarket paused trading for about an hour, ripped out the infected code, and later committed to returning $3.9 million to make every affected trader whole.

How the Polymarket Trading Halt Unfolded

At approximately 2:33 p.m. ET on October 29, traders watching their screens noticed positions liquidating and balances vanishing without a single confirmation prompt. One trader publicly reported watching $800,000 disappear as every open position got dumped, while a friend lost $600,000 in the same window.

Polymarket's response was fast. The platform flipped its international exchange into cancel-only mode and paused its transaction relayer to choke off unauthorized order execution. By 3:05 p.m. ET—roughly half an hour after the initial freeze—the team confirmed they had isolated the root cause, purged the malicious code, and restored normal trading.

Crucially, the blast radius stayed confined to Polymarket.com, the company's international platform. Polymarket US, which operates separately under Commodity Futures Trading Commission oversight, remained completely untouched. Polymarket also referred the breach to law enforcement in the United Kingdom, noting that the compromised third-party provider is headquartered there.

Inside the DebugBear Supply Chain Attack

Polymarket declined to publicly name the vendor in its official status updates. Security researchers closed that gap within hours. Threat intelligence firm Hudson Rock pulled the malicious payload directly from Polymarket's live frontend and traced it to cdn.debugbear.com—infrastructure belonging to DebugBear, a UK-based website performance monitoring company.

DebugBear provides Real User Monitoring (RUM) tools. Site operators drop a lightweight JavaScript snippet onto their pages to measure load times and core web vitals, then rarely think about it again. Because each DebugBear customer loads its own dedicated copy of the script, attackers didn't need to rewrite Polymarket's core codebase. They compromised DebugBear's side, swapped Polymarket's specific JavaScript file with a custom wallet drainer, and let Polymarket's own website serve the poison to visitors.

DebugBear later confirmed it had been hit by an active security incident, pulled its DNS records offline, brought in external incident responders, and urged all RUM customers to strip its embed code from their sites immediately.

Why Your Hardware Wallet Couldn't Save You

Most crypto users assume a hardware wallet or an air-gapped seed phrase makes them untouchable. That's a dangerous misconception on modern decentralized trading interfaces.

To give users a fast, gasless trading experience that feels like a traditional brokerage, platforms like Polymarket rely on session keys, local browser storage, and delegated signing mechanisms. Once you log in and authorize a trading session, your browser holds live cryptographic permission to sign orders and move position tokens.

Hudson Rock's static analysis of the hijacked DebugBear script revealed just how surgical the payload was:

  • Session detection: The script first checked whether the visitor had an active, authenticated Polymarket session running in their browser.
  • Credential harvesting: It scanned browser storage for account metadata, wallet addresses, and trading API credentials.
  • Live signer hijacking: Instead of tricking users into signing a fake transaction, the code tapped directly into Polymarket's active trading client and legitimate signed-batch rails.
  • Automated liquidation: Depending on the account structure, the malware either transferred position tokens directly or dumped holdings on the open market, routing proceeds into a hard-coded fallback wallet (0x3F99...Ffc18) and swapping assets into POL via Relay.
  • Telemetry exfiltration: After every hit, the script phoned home through DebugBear's own data endpoints to report the victim's wallet, country, portfolio size, and transfer status.

Because the malicious JavaScript executed inside the same browser context as Polymarket's legitimate application, the browser trusted it completely. Your hardware wallet never even knew a transaction was happening.

Tracking the Stolen Funds and the $3.9 Million Reimbursement

Depending on which blockchain analytics firm you ask and when they took their snapshot, the initial theft totaled somewhere between $2.5 million and $2.7 million across more than 700 accounts.

Blockchain researcher Conor Grogan pegged the drain at roughly $2.65 million. DefiPrime calculated that the attacker accumulated 28.6 million POL—worth approximately $2.64 million at the time—before rapidly splitting and forwarding the haul across three secondary addresses. According to AMLBot, the stolen assets were converted into USDC.e, bridged from Polygon over to Ethereum, swapped into ETH, and dispersed across fresh wallets to obscure the trail.

Polymarket didn't wait for law enforcement to recover a dime before stepping up. By early November, the company announced it was returning a total of $3.9 million to affected traders—a figure higher than initial on-chain POL snapshots because it accounts for liquidated market positions and slippage losses.

If you traded on Polymarket during the October 29 window, you don't need to submit a ticket or fill out a claim form to get paid. Polymarket automated the reimbursements directly to affected accounts, though its status page provides a dispute form for anyone who believes their payout calculation missed something.

Three Breaches in Six Months Expose a Pattern

Credit where it's due: absorbing a $3.9 million hit out of pocket and restoring service in under an hour is strong crisis management. Still, zoom out and an uncomfortable pattern emerges. October's breach was the third major security failure to hit Polymarket in less than six months.

Back in May 2026, a private key compromise drained roughly $700,000 from an internal top-up wallet. Just one month later, in June 2026, attackers breached a separate third-party vendor and injected malicious code into Polymarket's frontend, siphoning around $3 million from fewer than 15 high-value accounts.

Notice the common thread? Not a single one of these incidents broke Polymarket's underlying smart contracts. Every major loss came from operational perimeter failures—private key hygiene and third-party frontend scripts.

Prediction markets have exploded into mainstream finance in 2026, with Polymarket entertaining multi-billion-dollar valuations and institutional partnerships. Yet institutional counterparties and regulators don't just audit smart contracts; they scrutinize vendor risk management and custody controls. Letting a third-party analytics tool run unpinned JavaScript on the exact same page where users hold millions in active trading sessions is a structural gamble that mainstream financial infrastructure simply doesn't tolerate.

How Traders and Web3 Teams Can Lock Down Frontend Risk

You can't personally audit every analytics script a trading platform loads, and honestly, you shouldn't have to. Still, after watching three frontend-adjacent exploits hit a top-tier platform in a single year, relying blindly on browser convenience is a mistake.

If you trade significant capital on decentralized platforms or prediction markets, change how you interact with web frontends today:

  • Isolate your trading browser: Never use your daily-driver browser—the one loaded with extensions, cookies, and saved sessions—for high-value trading. Use a dedicated browser profile solely for signing transactions, and log out completely when you step away from your desk.
  • Revoke stale token approvals and API keys: Head to a tool like Revoke.cash or inspect your platform's active API and relayer permissions regularly. If an exploit relies on active session keys or delegated approvals, killing those permissions between sessions shrinks your exposure window to minutes instead of weeks.
  • Cap your hot balance: Treat any active browser-connected trading account like physical cash in your pocket. Keep only the collateral you actively need for open positions on the platform, and sweep profits back to cold storage.

For developers and engineering teams building financial applications, the DebugBear breach should be the final wake-up call. Keep non-essential third-party analytics, chat widgets, and performance trackers completely off authenticated trading routes. Where external scripts are unavoidable, enforce strict Content Security Policies (CSP) and pin file hashes using Subresource Integrity (SRI) so the browser automatically blocks any script whose contents change upstream. Until platforms treat every third-party JavaScript tag as potential root access to user funds, attackers will keep walking right through the front door.

NC

Nora Campbell

A dedicated content strategist and editor, Nora Campbell brings clarity and depth to complex topics. Committed to informing readers with accuracy and insight.