Agent skill

Polymarket Profile

by runesleo in runesleo/polymarket-toolkit

Polymarket address profiler — input any 0x address, get a complete trading profile with PnL, win rate, positions, category breakdown, and top trades.

MITAuto-check passedBusiness, Finance & HR

Install Polymarket Profile

skills CLI
$ npx skills add runesleo/polymarket-toolkit --skill polymarket-profile -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install runesleo/polymarket-toolkit polymarket-profile --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/runesleo/polymarket-toolkit.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/polymarket-profile .claude/skills/polymarket-profile && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
polymarket-profile
GitHub stars
194
Token cost
~3.7k tokens
SKILL.md length
1,517 words
Files
1
Skills in repo
2
Repo updated
First seen
Licence
MIT

At a glance

Polymarket address profiler — input any 0x address, get a complete trading profile with PnL, win rate, positions, category breakdown, and top trades.

  • Works in 7 steps: PnL Snapshot → Current Positions → Activity History → …
  • Tasks that involve Trading and backtesting
  • SKILL.md covers Trigger, Input Resolution, API Endpoints and Execution Steps, plus 1 more section
  • Calls curl; reaches lb-api.polymarket.com and data-api.polymarket.com

What it does

Polymarket Profile is an agent skill from runesleo/polymarket-toolkit. Polymarket address profiler — input any 0x address, get a complete trading profile with PnL, win rate, positions, category breakdown, and top trades. All data from public APIs, no local database needed.

Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Business, Finance & HR, covering Trading and backtesting and Performance optimization. It works with Polymarket and TypeScript. The repository describes itself as: CLI + AI Skills workflow for profiling Polymarket traders from an address. The licence is MIT.

When your agent uses it

  • Tasks that involve Trading and backtesting
  • Tasks that involve Performance optimization

Example prompts

  • “/polymarket-profile”

Requirements

  • Pre-approved tools (allowed-tools): Bash(curl:*), Bash(node:*), Read, Write, Edit

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. PnL Snapshot
  2. Current Positions
  3. Activity History
  4. Market Categories
  5. Strategy Pattern Detection
  6. Top Trades
  7. Assemble Profile

What it can do on your machine

Read from SKILL.md and the folder at commit 4a66e7d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash(curl:*)
    • Bash(node:*)
    • Read
    • Write
    • Edit

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • curl

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • lb-api.polymarket.com
    • data-api.polymarket.com
    • gamma-api.polymarket.com
    • clob.polymarket.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Polymarket Profile loads about 3.7k tokens when it runs. Until then it costs about 55 tokens; SKILL.md has 1,517 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~55
When it runs · the whole SKILL.md, loaded when a task matches
~3.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from runesleo/polymarket-toolkit at commit 4a66e7d, republished under its MIT licence (© runesleo). 1,517 words, ~3,735 tokens.

Download SKILL.mdSave it as .claude/skills/polymarket-profile/SKILL.md (or your agent's skills folder).
name
polymarket-profile
description
Polymarket address profiler — input any 0x address, get a complete trading profile with PnL, win rate, positions, category breakdown, and top trades. All data from public APIs, no local database needed.
allowed-tools
Bash(curl:*), Bash(node:*), Read, Write, Edit
metadata.version
0.2.0

Polymarket Address Profile

Generate a complete trading profile for any Polymarket address. All data comes from public APIs in real-time — no local database or API key required.

Trigger

User provides a Polymarket identity and wants analysis, profile, or trading overview.

Input Resolution

The skill requires a 0x proxy wallet address. Users may provide:

Input TypeExampleHow to handle
0x address0x63ce3421...Use directly
Profile URLpolymarket.com/profile/Theo4Extract username from URL, then resolve via leaderboard lookup (see below)
UsernameTheo4Resolve via leaderboard lookup (see below)
When user provides a username or URL (not 0x address)

Step 1: Try leaderboard lookup — Search lb-api.polymarket.com/profit to resolve username → address.

bash
# Paginate through the leaderboard searching for the username
# Start with offset=0, increment by 500 until found or no more results
curl -s "https://lb-api.polymarket.com/profit?window=all&limit=500&offset=0"

Response is an array of objects with name, pseudonym, and proxyWallet fields. Search for a case-insensitive match on name or pseudonym.

  • Found → use the proxyWallet as the 0x address, continue to Step 1 of execution
  • Not found after 3 pages (1500 users) → the account is likely unranked, fall back to Step 2

Step 2: Manual fallback (only if leaderboard lookup fails)

"This username isn't in the Polymarket leaderboard (only ranked users can be auto-resolved). You can find the 0x address by:

  1. Open the profile page on Polymarket
  2. Click the address/wallet icon near the username — it copies the 0x address
  3. Or check the browser URL — some profile pages show the address"

NOTE: Leaderboard lookup covers all users with a PnL ranking (tens of thousands). Only very new or inactive accounts with zero trading history won't be found.

API Endpoints

All endpoints are public, no authentication needed.

EndpointBase URLPurpose
LB APIhttps://lb-api.polymarket.comPnL, volume, rankings
Data APIhttps://data-api.polymarket.comPositions, activity, trades
CLOB APIhttps://clob.polymarket.comOrderbook, market prices
Gamma APIhttps://gamma-api.polymarket.comMarket metadata, events, categories

Execution Steps

Run steps 1-4 in parallel where possible to minimize latency.

Step 1: PnL Snapshot
bash
curl -s "https://lb-api.polymarket.com/profit?window=all&address={ADDRESS}"

Response is an array. Extract [0].amount for total PnL, [0].name for username.

NOTE: lb-api only returns amount (total PnL). It does NOT return invested/numTrades/numWins. Those must be computed from positions (Step 2) and activity (Step 3).

Also fetch time-windowed PnL for trend:

bash
curl -s "https://lb-api.polymarket.com/profit?window=7d&address={ADDRESS}"
curl -s "https://lb-api.polymarket.com/profit?window=30d&address={ADDRESS}"
Step 2: Current Positions
bash
curl -s "https://data-api.polymarket.com/positions?user={ADDRESS}&sizeThreshold=0&limit=100&offset=0"

Paginate with offset parameter: if response returns exactly 100 records, fetch next page with offset=100, offset=200, etc. until fewer than 100 returned.

Each position object contains:

FieldDescription
titleMarket question
outcome"Yes" or "No"
sizeNumber of shares held
avgPriceAverage entry price
curPriceCurrent market price
initialValueTotal cost (size × avgPrice)
currentValueCurrent value (size × curPrice)
cashPnlRealized + unrealized PnL
percentPnlPnL as percentage
totalBoughtTotal shares ever bought
realizedPnlPnL from closed portions
redeemableCan claim settlement winnings
endDateMarket expiry date
eventSlugEvent identifier for Gamma API

Extract:

  • Number of open positions: redeemable == false AND currentValue > 0
  • Largest position by currentValue
  • Total portfolio value: sum of currentValue for open positions
Win Rate Calculation

Classify positions into three buckets:

BucketConditionMeaning
Wonredeemable == true AND currentValue > 0Market settled in user's favor, awaiting redemption
Lostredeemable == true AND currentValue == 0Market settled against user
Openredeemable == false AND currentValue > 0Market not yet settled

Win Rate = Won / (Won + Lost)

IMPORTANT: Do NOT use cashPnl > 0 to determine wins. Winning positions have currentValue > 0 (shares worth $1) even if cashPnl appears negative due to partial sells. The redeemable flag is the definitive settlement indicator.

Fallback: When Positions Are Empty or Incomplete

For inactive accounts, the positions API may return very few records (settled positions get cleaned up). If Won + Lost < 3, fall back to activity-based estimation:

  1. From activity, group all REDEEM records by slug (market)
  2. From activity, group all TRADE records by slug
  3. Markets with REDEEM volume > 0 → Won
  4. Markets with TRADE volume > 0 but no REDEEM → Lost (invested but no payout)
  5. Label Win Rate as "estimated from activity" when using this fallback
Step 3: Activity History
bash
curl -s "https://data-api.polymarket.com/activity?user={ADDRESS}&limit=500"

IMPORTANT: You MUST paginate to get complete data. Large accounts have 10,000+ records. 500 records is NOT enough for an accurate profile.

Activity Pagination (REQUIRED)
Loop:
  1. First request: /activity?user={ADDRESS}&limit=500
  2. Get `timestamp` of the LAST record in the response
  3. Next request: /activity?user={ADDRESS}&limit=500&end={last_timestamp}
  4. Repeat until response returns fewer than 500 records (= last page)
  5. Merge all results

Inform user of progress for large accounts: "Fetching activity... page X (Y records so far)"

Each activity object contains: type, size, usdcSize, price, side, title, slug, timestamp, outcome.

Classify by type field:

TypeWhat it means
TRADEBought or sold shares (check side field: "BUY" or "SELL")
SPLITCreated YES+NO pairs from USDC (market-neutral entry)
MERGECombined YES+NO back to USDC (exit / arbitrage capture)
REDEEMClaimed winnings after market settlement
CONVERSIONConverted between YES/NO (special market operation)
REBATEFee rebate from maker orders

Count and sum usdcSize for each type. Also track unique markets (slug) for diversity analysis.

Step 4: Market Categories

For each position, fetch market metadata via Gamma API using the eventSlug from positions:

bash
curl -s "https://gamma-api.polymarket.com/events?slug={eventSlug}"

Or batch multiple slugs. Each event has a category field and a tags array (each tag has a label field).

Category Mapping

Gamma API categories are legacy naming. Map to Polymarket's frontend categories:

Gamma category / tag labelDisplay Category
Sports, NBA Playoffs, Chess, Esports, any sports team nameSports
Crypto, NFTs, Bitcoin, EthereumCrypto
US-current-affairs, Elections, any president/congress/party keywordPolitics
Ukraine & Russia, Iran, any war/military/invasion keywordGeopolitics
Business, any GDP/oil/fed/rate keywordFinance
Pop-Culture, Art, CoronavirusCulture
temperature/weather/celsius keyword in titleWeather
AI/tech/SpaceX keyword in titleTech
Musk/tweet keyword in titleMusk/Tweets
No matchOther

Priority: Use Gamma category field first. If it's missing or too generic (All), fall back to tag labels. If still unclear, infer from market title keywords.

NOTE: Gamma API may return empty [] for old/settled markets. This is expected — fall back to keyword inference from market titles in activity data.

Optimization: Collect all unique eventSlug values from positions first, then batch fetch from Gamma (avoid one API call per position). Group by slug to avoid duplicates.

Compute the percentage distribution by volume invested.

Show full SKILL.md (569 more words)Show less
Step 5: Strategy Pattern Detection

Analyze data from Steps 1-4 to classify the address into a trading pattern. Use multiple dimensions — no single metric is sufficient.

Dimensions to compute

From activity data:

  • trade_count: total TRADE records
  • split_count / split_volume: SPLIT records and USDC volume
  • merge_count / merge_volume: MERGE records and USDC volume
  • redeem_volume: total REDEEM volume
  • unique_markets: number of distinct slug values
  • avg_trade_size: total trade volume / trade count
  • trade_frequency: trade count / active days (first to last timestamp)

From positions data:

  • open_count: open positions (not redeemable)
  • settled_count: won + lost
  • concentration: top 3 positions as % of total invested
Pattern Classification

Evaluate in this order (first match wins):

PatternConditionsDescription
SPLIT Arbitragesplit_volume > trade_volume × 0.2 AND merge_volume > 0Enters via SPLIT (creates YES+NO pairs), sells one side or MERGEs back. Capital-efficient, market-neutral entry.
Market Makertrade_count > 500 AND unique_markets < 15 AND avg_trade_size < $20High-frequency small trades concentrated in few markets. Provides liquidity, earns spread.
Whale / Concentratedconcentration > 60% AND unique_markets < 10Heavy capital in a few markets. High-conviction directional bets.
Diversifiedunique_markets > 50Spread across many markets. Portfolio approach, lower per-market risk.
Small Tradertrade_count < 50 AND total_invested < $500Limited activity. New or casual user.
MixedNone of the aboveCombination of strategies, no dominant pattern.
Output format
🎯 Strategy Pattern: {pattern_name}
   {1-2 sentence explanation based on actual numbers}
   Key metrics: {trade_count} trades across {unique_markets} markets, avg ${avg_trade_size}/trade

Do NOT reveal specific thresholds used for classification. Just state the pattern name and explain it in plain language using the trader's actual data.

Step 6: Top Trades

From positions data (not activity), use cashPnl field for settled positions:

  • Top 5 Wins: Settled positions with highest positive cashPnl
  • Top 5 Losses: Settled positions with most negative cashPnl

For each: market title, outcome (Yes/No), entry price (avgPrice), PnL amount.

NOTE: cashPnl from positions is approximate (affected by partial sells). This is acceptable for v0.1. Do NOT attempt to match individual BUY→SELL/REDEEM from activity — that requires complex logic and is not worth the accuracy gain for a profile overview.

Fallback: When Positions Data Is Sparse

If positions API returns very few settled records, estimate Top Trades from activity:

  1. Group TRADE records by slug, sum usdcSize per market (= total invested)
  2. Group REDEEM records by slug, sum usdcSize per market (= total payout)
  3. PnL per market ≈ REDEEM volume - TRADE BUY volume
  4. Sort by PnL for top wins/losses. Label as "estimated from activity".
Step 7: Assemble Profile

Output the complete profile in this format:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Polymarket Profile: {ADDRESS_SHORT}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 Overview
  Address:    {ADDRESS}
  Total PnL:  ${totalProfit} (invested ${invested})
  Win Rate:   {wins}/{total} ({winRate})
  7d PnL:     ${pnl_7d}
  30d PnL:    ${pnl_30d}

📈 Current Positions ({count})
  Largest:    {market_name} — {direction} ${size} @ ${avg_price}
  Portfolio:  ${total_value}

  | # | Market | Direction | Size | Avg Price | Current | PnL |
  |---|--------|-----------|------|-----------|---------|-----|
  | 1 | ...    | YES/NO    | $xx  | $0.xx     | $0.xx   | +$x |
  ...

📂 Category Distribution
  | Category | Positions | Volume | % |
  |----------|-----------|--------|---|
  | Crypto   | 12        | $5,000 | 45% |
  | Politics | 5         | $2,000 | 22% |
  ...

📋 Activity Summary
  | Type       | Count | Volume |
  |------------|-------|--------|
  | TRADE BUY  | xxx   | $xxx   |
  | TRADE SELL | xxx   | $xxx   |
  | SPLIT      | xxx   | $xxx   |
  | MERGE      | xxx   | $xxx   |
  | REDEEM     | xxx   | $xxx   |

🏆 Top Wins
  1. {market} — {direction} +${pnl} (entry ${price} → ${exit})
  2. ...
  3. ...

💀 Top Losses
  1. {market} — {direction} -${pnl} (entry ${price} → ${exit})
  2. ...
  3. ...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Generated: {timestamp} | Data: Polymarket Public APIs
  Powered by Leo Labs — leolabs.me
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Important Notes

  • PnL from lb-api is the ground truth. Use it as the primary source. Position-level cashPnl may differ due to SPLIT/MERGE accounting.
  • Activity pagination: use end timestamp, never offset. Do NOT deduplicate — same txHash with multiple records means multiple fills in one transaction.
  • Always paginate ALL activity records. Partial data produces inaccurate profiles. Show pagination progress to the user (e.g. "Fetching activity... page 5, 2500 records so far").
  • Category mapping: use eventSlug from positions to query Gamma API. Category comes from the event's tags or category field. If Gamma is slow, infer from market title keywords (BTC/ETH/crypto → Crypto, Trump/election → Politics, NBA/FIFA → Sports, temperature/weather → Weather).
  • All monetary values in USD, round to 2 decimal places.
  • Address format: APIs accept both checksummed and lowercase. Normalize to lowercase.
  • lb-api may require proxy in some regions. data-api and gamma-api work globally.
  • Rate limits: No documented limits, but keep requests reasonable (<10 concurrent). Add 500ms delay between sequential pagination calls. If a request returns empty or non-JSON, retry once after 2 seconds.
  • lb-api 7d/30d: May return empty array [] for inactive accounts. Display as "N/A" instead of $0.

© runesleo, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/polymarket-profile of runesleo/polymarket-toolkit.

Open the folder on GitHubat commit 4a66e7d

Compare with similar skills

Polymarket Profile next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Polymarket Profile compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Polymarket Profile this skillrunesleo/polymarket-toolkit194—~3.7kAutomated safety check: PassMIT
Polymarket Tennislivetennisapi/livetennisapi-mcp152—~3kAutomated safety check: PassMIT
Web3 PolymarketPolymarket/agent-skills1921 repos~2kAutomated safety check: PassNone
Digital Oraclekomako-workshop/digital-oracle878—~5.9kAutomated safety check: PassMIT
Polyclawchainstacklabs/polyclaw3591 repos~2kAutomated safety check: PassApache-2.0
Polymarket TradingBlockRunAI/ClawRouter6.6k—~1.4kAutomated safety check: PassMIT

Similar skills

  • Polymarket Tennis

    livetennisapi/livetennisapi-mcp

    Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier.

    152 GitHub stars~3k tokensUpdated 4 days ago
    Business, Finance & HRAuto-check passed
  • Web3 Polymarket

    Polymarket/agent-skills

    Polymarket integration for prediction market trading on Polygon.

    192 GitHub starsUsed in 1 repo~2k tokens
    Backend & APIsAuto-check passed
  • Digital Oracle

    komako-workshop/digital-oracle

    Answer prediction questions using market trading data, not opinions.

    878 GitHub stars~5.9k tokensUpdated 2 mo ago
    Business, Finance & HRAuto-check passed
  • Polyclaw

    chainstacklabs/polyclaw

    Trade on Polymarket via split + CLOB execution. An agent skill from chainstacklabs/polyclaw.

    359 GitHub starsUsed in 1 repo~2k tokens
    Business, Finance & HRAuto-check passed
  • Polymarket Trading

    BlockRunAI/ClawRouter

    A skill your agent uses when the user wants to actually PLACE, manage, or redeem bets on Polymarket (not just read odds — that's the blockrunpredexon data tools).

    6.6k GitHub stars~1.4k tokensUpdated 5 days ago
    Business, Finance & HRAuto-check passed
  • Dr Manhattan

    guzus/dr-manhattan

    Trade prediction markets (Polymarket, Kalshi, Opinion, Limitless, Predict.fun) using a unified CCXT-style API.

    204 GitHub stars~2k tokensUpdated 2 mo ago
    Business, Finance & HRAuto-check passed

More from runesleo/polymarket-toolkit

  • Polymarket Brier

    runesleo/polymarket-toolkit

    Brier Score calculator for Polymarket addresses — measures prediction accuracy independent of PnL.

    194 GitHub stars~1.3k tokensUpdated 1 mo ago
    Auto-check passed

Questions about Polymarket Profile

What does Polymarket Profile do?

Polymarket address profiler — input any 0x address, get a complete trading profile with PnL, win rate, positions, category breakdown, and top trades. Polymarket Profile is an agent skill from runesleo/polymarket-toolkit. Polymarket address profiler — input any 0x address, get a complete trading profile with PnL, win rate, positions, category breakdown, and top trades.

When should I use Polymarket Profile?

Polymarket Profile fits situations like: tasks that involve Trading and backtesting; tasks that involve Performance optimization.

How do I install Polymarket Profile in Claude Code?

Run `npx skills add runesleo/polymarket-toolkit --skill polymarket-profile -a claude-code`. Or copy the skill folder (skills/polymarket-profile in runesleo/polymarket-toolkit) into .claude/skills/polymarket-profile in your project. Claude Code loads it when a task matches its description.

How do I install Polymarket Profile in Codex?

Run `npx skills add runesleo/polymarket-toolkit --skill polymarket-profile -a codex`. Or copy the skill folder (skills/polymarket-profile in runesleo/polymarket-toolkit) into .agents/skills/polymarket-profile in your project. Codex loads it when a task matches its description.

Can I use Polymarket Profile in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add runesleo/polymarket-toolkit --skill polymarket-profile -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/polymarket-profile, .gemini/skills/polymarket-profile, .github/skills/polymarket-profile and .opencode/skills/polymarket-profile in your project.

What does Polymarket Profile need to run?

Going by SKILL.md and its folder, Polymarket Profile needs the command-line tools its instructions call (curl). Its frontmatter pre-approves these tools: Bash(curl:*), Bash(node:*), Read, Write, Edit.

Does Polymarket Profile access the network?

SKILL.md names 4 domains. In commands or code: lb-api.polymarket.com, data-api.polymarket.com, gamma-api.polymarket.com and clob.polymarket.com; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Polymarket Profile safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Polymarket Profile use?

Polymarket Profile is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Polymarket Profile use?

About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Polymarket Profile?

Skills that share tags, products or a category with Polymarket Profile: Polymarket Tennis (livetennisapi/livetennisapi-mcp, 152 stars), Web3 Polymarket (Polymarket/agent-skills, 192 stars), Digital Oracle (komako-workshop/digital-oracle, 878 stars) and Polyclaw (chainstacklabs/polyclaw, 359 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Polymarket Profile?

runesleo (a GitHub user) maintains it in runesleo/polymarket-toolkit, which has 194 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on September 9, 2026.

Source: runesleo/polymarket-toolkit on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.