Polymarket Auto-Trader

fully autonomous prediction market trading agent for Polymarket. evaluates markets using LLM probability estimation, sizes positions with Kelly criterion, and executes trades via the Polymarket CLOB API from a non-US VPS.

intent

use this skill to set up an autonomous trading bot that scans Polymarket prediction markets, evaluates fair value using Claude Haiku, detects pricing edges (5%+ mispricing), and executes limit orders via the CLOB API. the bot runs on cron (default every 10 minutes), applies Kelly criterion position sizing with safety caps, deduplicates trades to avoid re-trading the same market, and tracks P&L separately from inference costs. run this when you want hands-off prediction market trading, need to backtest LLM-driven market evaluation, or want to test autonomous DeFi execution on Polygon without US-based IP.

inputs

external connections:

• Polymarket Gamma API , fetches active markets, liquidity, order books (no auth required, but rate-limited to ~10 req/sec)
• Polymarket CLOB API , executes trades, queries order status (HTTP endpoint at https://clob.polymarket.com)
• Anthropic Claude Haiku API , evaluates market probabilities (requires API key, ~$0.001 per inference)
• Polygon RPC , sends blockchain transactions (gas estimation, contract approvals, order settlement). suggest Infura, Alchemy, or public endpoints like https://polygon-rpc.com

environment variables (required):

• PRIVATE_KEY , Polygon wallet private key (EOA only, not proxy wallet). funds must be on Polygon network. store in .env with strict permissions (chmod 600).
• LLM_API_KEY , Anthropic API key for Claude Haiku. set billing alerts at ~$0.04 per 10-minute cycle (40 market evals).

wallet prerequisites:

• non-US VPS , Polymarket blocks US IPs. use DigitalOcean Amsterdam, Hetzner EU, Linode Singapore, or AWS eu-central-1.
• Polygon USDC.e balance , bridged USDC (0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174), NOT native USDC. minimum ~$100 recommended for meaningful position sizing.
• MATIC for gas , 0.1 MATIC ($0.05) sufficient for hundreds of trades. Polygon gas is negligible (~$0.001 per trade).
• token approvals , USDC.e and CTF token approvals set up for three Polymarket contracts (CTF Exchange, Neg Risk Exchange, Neg Risk Adapter). run approval script before first trade.

local files (created during setup):

• .env , configuration file with PRIVATE_KEY and LLM_API_KEY
• trades.jsonl , append-only log of all executed trades for deduplication
• cron.log , stdout/stderr from cron runs
• references/contract-addresses.md , verified Polygon contract addresses (external reference, must match official docs)
• references/polymarket-api.md , CLOB API endpoint specs (external reference)

procedure

step 1: provision non-US VPS

rent a VPS outside US with SSH access. note IP geolocation. SSH in and run:

apt update && apt install -y python3 python3-venv git curl
python3 -m venv /opt/trader
/opt/trader/bin/pip install py-clob-client python-dotenv web3 requests

input: VPS IP verified as non-US (use curl ifconfig.me to verify) output: Python venv at /opt/trader with dependencies installed; confirm with /opt/trader/bin/python3 --version

step 2: create .env file on VPS

SSH into VPS and create /opt/trader/app/.env:

mkdir -p /opt/trader/app
cat > /opt/trader/app/.env << 'EOF'
PRIVATE_KEY=0x<your-polygon-wallet-private-key>
LLM_API_KEY=sk-ant-<your-anthropic-key>
EOF
chmod 600 /opt/trader/app/.env

replace values with your actual keys. validate PRIVATE_KEY is valid Polygon EOA (not proxy wallet).

input: polygon wallet private key (string), anthropic API key (string) output: .env file on disk with 600 permissions; confirm with ls -la /opt/trader/app/.env

step 3: execute blockchain token approvals

copy the approval script to VPS and run:

python3 /opt/trader/app/approve_contracts.py

this script approves USDC.e and CTF token spending to three Polymarket contracts: CTF Exchange (0x4bCE41985E38a9B94381f7c12dF2c3fdD0B67Cd1), Neg Risk Exchange (0xC5d563A36AE78145C45a50134d48a1215220f80a), Neg Risk Adapter (0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296). approvals use unlimited (MAX_UINT) to avoid re-approval per trade. script polls for confirmation (wait up to 2 minutes per approval).

input: .env file with PRIVATE_KEY and RPC endpoint (default Polygon public RPC); USDC.e balance required (~0.001 minimum for gas) output: 6 blockchain transactions confirmed (2 tokens x 3 contracts); confirm with python3 -c "from web3 import Web3; w3=Web3(...); print(w3.eth.get_balance(YOUR_ADDR))" showing reduced MATIC balance edge case: if approval tx reverts, likely cause is insufficient gas; fund VPS wallet with 0.5 MATIC and retry.

step 4: deploy trading scripts

copy main trading logic and monitoring tools:

cp {baseDir}/scripts/run_trade.py /opt/trader/app/
cp {baseDir}/scripts/pnl_tracker.py /opt/trader/app/

input: source repo with scripts output: two executable Python files in /opt/trader/app/; confirm with ls -la /opt/trader/app/run_trade.py

step 5: test single execution

run the trading script once manually to verify wallet, approvals, and market connectivity:

cd /opt/trader/app && /opt/trader/bin/python3 run_trade.py

watch for:

• "fetched N active markets" (confirm API reachability)
• "evaluated M markets with LLM" (confirm API key works)
• "found K tradeable opportunities" (confirm Kelly sizing logic)
• "placed N orders" or "no tradeable edges found" (expected; trading depends on current market conditions)
• no auth/wallet errors

input: .env with valid keys, blockchain approvals already executed output: console logs showing market fetch, LLM evaluation, Kelly sizing, and order results; no exceptions. edge case: if you see "network timeout" or "US IP detected", check VPS geolocation and restart.

step 6: set up cron automation

add cron job to execute script every 10 minutes:

crontab -e

add line:

*/10 * * * * cd /opt/trader/app && /opt/trader/bin/python3 run_trade.py >> cron.log 2>&1

save and verify with crontab -l.

input: crontab access on VPS, run_trade.py deployed output: cron job scheduled; confirm with crontab -l and check that cron.log grows every 10 minutes with tail -f /opt/trader/app/cron.log edge case: if cron fails silently, check cron logs with journalctl -u cron and verify .env permissions.

step 7: monitor P&L and activity

run anytime to check performance:

python3 /opt/trader/app/pnl_tracker.py

reads trades.jsonl and outputs realized/unrealized P&L, total fees, cost per trade, and Sharpe ratio estimate.

input: trades.jsonl from previous executions (empty on first run) output: console report with format: "realized_pnl=, unrealized_pnl=, total_fees=, trade_count=" edge case: if P&L is negative, verify edge threshold and Kelly parameters are appropriate for market conditions.

decision points

if user has non-US VPS with static IP: deploy directly to that VPS using procedure steps 1-7.

else (no VPS available): rent one from DigitalOcean, Hetzner, Linode, or AWS in a non-US region (Amsterdam, Frankfurt, Singapore verified). do not use VPN or proxy on a US VPS; Polymarket blocks Tor and residential proxies.

---

if wallet has USDC.e balance and MATIC for gas (>0.1): proceed to blockchain approvals (step 3).

else: bridge USDC to Polygon via official bridge (polygon.technology) and fund MATIC via Polygon faucet or exchange.

---

if approval transactions are pending after 2 minutes: check tx status on Polygonscan; if stuck, increase gas price via approve_contracts.py --gas-price=100 (gwei) and resubmit.

else if approval reverts: error is usually insufficient MATIC. fund wallet with 1.0 MATIC and retry.

---

if single test run (step 5) returns "no tradeable edges found": this is normal; markets may not have >5% mispricing right now. wait one cron cycle and check again. if persistent, lower EDGE_THRESHOLD in run_trade.py from 0.05 to 0.03 (3%).

else if test run errors (auth, network, wallet): halt cron, check .env file, verify VPS IP with curl ifconfig.me, and re-run approval script.

---

if LLM evaluation fails (API timeout, quota exceeded): script catches this and logs "LLM eval failed, skipping market X". check Anthropic dashboard for usage and quota. if exceeded, wait until billing period resets or increase budget.

---

if executed trade is not reflected in order book within 30 seconds: check cron.log for "order rejected" message. likely cause is stale price data or insufficient liquidity. script retries on next cycle; no manual action needed.

---

if cron.log shows repeated failed orders on same market: add that market to skip list (edit run_trade.py to append market ID to skip_markets.txt). script checks this file before evaluation and deduplicates.

output contract

success state:

• cron job runs every 10 minutes without errors
• cron.log shows at least 10 lines per day (one per execution)
• trades.jsonl contains at least one trade record with schema: {"market_id": "str", "timestamp": "iso8601", "position": "buy|sell", "shares": "int", "price": "float", "kelly_fraction": "float", "edge_pct": "float"}
• pnl_tracker.py output shows numeric P&L values (can be negative)
• Polygon wallet balance decreases slightly with each trade (USDC.e outflow + MATIC gas fee, typically <$0.01 per trade)

file locations:

• configuration: /opt/trader/app/.env (not committed to repo)
• trade history: /opt/trader/app/trades.jsonl (append-only)
• monitoring log: /opt/trader/app/cron.log (rotated if >100MB)
• P&L report: printed to stdout from pnl_tracker.py (can be piped to file)

data formats:

• market data from Gamma API: JSON with fields market_id, question, end_date, liquidity, order_book
• LLM evaluation: Claude Haiku response parsed as probability float (0.0-1.0)
• executed orders: CLOB API response with fields order_id, status, filled_amount, price

outcome signal

user knows skill worked when:

1. VPS is live , SSH access confirmed, curl ifconfig.me shows non-US IP, Python venv installed
2. approvals are set , blockchain explorer (Polygonscan) shows 6 approval transactions from your wallet to Polymarket contracts, all with status "success"
3. first manual test runs , execute run_trade.py once and see console output showing market fetch, LLM calls, and either "X orders placed" or "no tradeable edges"
4. cron is active , run crontab -l and see the */10 schedule; tail /opt/trader/app/cron.log shows new lines every 10 minutes (or on next scheduled run)
5. trades execute , check Polygonscan for your wallet's recent transactions; you'll see CLOB API order submissions and USDC.e balance changes matching trades.jsonl
6. P&L tracks , run pnl_tracker.py and get numeric output; over time (1-2 weeks), you'll see trade volume accumulate in trades.jsonl

tangible signals (within 24 hours of setup):

• at least 2-5 orders attempted (edge-dependent)
• cron.log grows continuously (no "connection refused" or "US IP" errors)
• wallet USDC.e balance lower than starting amount (capital deployed)
• no manual intervention needed; script runs unattended

note: the bot is probabilistic; not every cycle will find tradeable edges. zero trades in a day is normal if markets are efficiently priced. persistent zero activity suggests edge threshold is too high; lower EDGE_THRESHOLD and restart cron.

---

original author: clawhub. enriched to follow Implexa standards with explicit decision logic, edge cases, and verified output contract.